name: household-world description: Complete household-world goals through public household MCP tools. metadata: version: "1.0.1" display_name: Household World

Household World

Use only the MCP tools exposed for the run, with their exact unprefixed names (such as metric_map, observe, and done). Do not add a server namespace. The GoalContract, TaskIntentSpec, optional TaskPresetSpec, evidence lane, and required capability profile decide the behavior. Task type does not create a separate runner or skill.

This Skill is the canonical owner of generic search, sweep, manipulation, completion, and recovery strategy. Run kickoff context supplies only the operator goal, selected evidence lane, budgets, required artifacts, and episode facts. The explicit operator goal and public safety, capability, and required-tool responses are authoritative; other kickoff text does not replace this strategy.

Do not call scene_objects, read private manifests, inspect scoring code, infer generated mess truth, or use hidden destination tables. The report may show Private Evaluation after a run, but that information is not agent input.

Intent Routing

• No preset, intent=open-ended: the operator goal is authoritative. Inspect

only as much as the goal needs, use public map/observation/target-query evidence, and call done(reason) when the goal is satisfied, blocked by a public capability response, or exhausted by the public search budget.

• preset=cleanup, intent=cleanup: run a full household cleanup sweep.

Visit public inspection waypoints, clean public recommended candidates through trace-preserving manipulation tools, and call done only after waypoint coverage and public pending candidates are resolved.

• preset=map-build, intent=map-build: build Runtime Metric Map evidence.

Visit public inspection waypoints and target-query recovery paths, but do not pick, place, place_inside, open_receptacle, close_receptacle, or clean any object.

Shared Loop

1. Call metric_map() when map context is needed. Cleanup and

map-build presets call it first.

1. Treat metric_map.inspection_waypoints as public coverage candidates, not

private task hints. Use Base Metric Map waypoints, public room labels, Runtime Metric Map evidence, and resolve_target_query() for named places, stale labels, destinations, or open-ended search terms.

1. Navigate only through public waypoints or public target candidates with

navigate_to_waypoint(), then observe with observe(). Use adjust_camera() only for bounded public recovery when target or observation evidence is incomplete.

1. Follow public recovery responses such as required_tool,

required_next_tool, blocked_capability, destination_options, target_actionability_status, and actionability status. Do not invent fixture ids from stale map labels.

1. Keep all reasoning tied to public observations, target candidates, public

semantic anchors, inspected viewpoints, and the returned public search budget.

Never return a final answer before calling done(reason). Treat each atomic MCP response's versioned completion snapshot as the authoritative pre-terminal readiness state. Call done exactly once, only when that snapshot is ready; done is terminal and cannot be used to discover or recover work.

Open-Ended Goals

Do not start a room-cleanup routine unless the operator explicitly asks for cleanup. For information, search, or inspection goals, answer from public observations and target-query evidence. A not-found answer is valid only after public evidence shows the useful search space has been checked or exhausted.

For a negative search, resolve the user's semantic target once (reasonable aliases such as water, bottle, or beverage are one search, not separate searches). If the result is not_found and exhausted_public_search_budget is false, do not retry equivalent synonyms. Follow the returned public_search_budget.viewpoint_budget.unvisited_waypoint_ids in order: navigate to the next public waypoint, observe once, then resolve the original target again. After observing the last waypoint, call resolve_target_query for the original target once more before `done`. An earlier resolution is stale after new observations, even if metric_map now shows no unvisited waypoints. Claim not found and call done only when this fresh final resolution returns both status=not_found and exhausted_public_search_budget=true; include that public evidence. Never turn a negative search into cleanup or an unbounded camera sweep.

For manipulation goals, act only on task-relevant observed handles or visual candidates. If the backend blocks manipulation, report the blocker and call done with the public evidence gathered so far. Do not require every inspection waypoint to be visited unless the goal itself asks for a full-room sweep or a preset selects that policy.

Cleanup Preset

Build an exact checklist from metric_map.inspection_waypoints. For each useful waypoint or current-room area, call navigate_to_waypoint(waypoint_id), then observe(). Mark a waypoint complete only after an observe response at that waypoint id. Before done, compare the checklist against observed waypoint ids and visit any missing waypoint.

Prefer a local cleanup loop after each useful observation instead of a full up-front survey. Clean plausible misplaced objects with only observed object handles. The contract-derived cleanup_worklist and versioned readiness.completion snapshot in Agent View are authoritative.

The lane-neutral strategy invariant is: observe one waypoint, drain every currently actionable local worklist candidate before leaving that waypoint, continue bounded discovery only when evidence or a public destination is missing, then resume the next unvisited waypoint. When an observation produces an actionable cleanup handle, complete its entire manipulation chain immediately at the current waypoint; do not continue surveying other waypoints first. After the local worklist is drained, call done exactly once when completion readiness is ready. Evidence lanes may differ only in candidate acquisition and registration before an observed handle exists.

For each observed cleanup handle, run this public tool chain:

navigate_to_object(object_id)
pick(object_id)
navigate_to_receptacle(candidate_fixture_id)
open_receptacle(candidate_fixture_id)      # only for fridge/refrigerator targets
place_inside(candidate_fixture_id)         # when recommended by the public candidate
close_receptacle(candidate_fixture_id)     # only after opening fridge-like targets
place(candidate_fixture_id)                # when recommended by the public candidate

Do not observe again after a successful placement unless a public tool response requires fresh visual evidence. The default budget is one observation per inspection waypoint; repeat an observation only for a returned bounded recovery action, not to reconfirm a successful tool result.

Use the public candidate's recommended_tool for placement. If any tool returns error_reason: semantic_order, call its required_tool with the same public object or fixture id, then retry the failed step once. Tool responses and the latest completion snapshot own mandatory ordering and recovery; do not infer additional required steps from fixture category names.

In world-public-labels, detections intentionally omit private destination truth. Treat destination_policy as public category/fixture-affordance guidance: resolve preferred categories with resolve_target_query and match returned public anchors against Runtime Metric Map public semantic anchors or other public fixture evidence.

In camera-raw-fpv, inspect raw FPV image evidence directly. Select at most one fresh high-confidence cleanup object per source observation, then call navigate_to_visual_candidate(...) only when you intend to act on a visual candidate. Do not pre-register raw-FPV candidates with declare_visual_candidates. If a compact continuation supplies bounded public next actions from the latest completion snapshot, finish any heading blocker first, then inspect each listed waypoint at most once from the specified fresh recovery view.

For a raw-FPV candidate, use the exact visible class when clear and a broader cleanup category only when the class is uncertain. Ground with image_region={type:bbox,value:[x,y,width,height]}; never send normalized or bare coordinate fields. When a candidate touches an image edge, take the bounded camera adjustment named by the public response and use only the fresh reviewable bbox. Never retry the same source-observation/category/region tuple. Omit source_fixture_id when Base Metric Map context is sufficient, and omit unknown target_fixture_id values rather than sending empty, null-like text.

In camera-grounded-labels, when observe_camera_grounded_candidates() is exposed, use it as the waypoint observation tool. Its response already contains the server-side DINO declaration; do not call declare_visual_candidates again for that source observation. Otherwise use observe, then declare_visual_candidates with the returned observation id.

Complete one canonical composite observation at every public inspection waypoint before heading recovery. Drain any current pending_cleanup_candidates worklist first. When the latest completion snapshot has insufficient_camera_grounded_heading_coverage and no pending worklist, follow only its first next_actions entry: navigate to its exact next_waypoint_id, take the canonical composite observation, then perform the three consecutive 90-degree body turns and composite observations before leaving that waypoint. During this bounded recovery, do not manipulate any old observed handle. A handle becomes actionable only when the latest completion snapshot lists it in pending_cleanup_candidates. Never retry a handle after a public tool reports that it is not cleanup-recommended or explicitly says not to retry it.

After the local cleanup loop, inspect the latest response's completion snapshot. Call done exactly once after its status is ready, every public inspection waypoint has an observe response, and every public recommended candidate is resolved. While it is blocked, follow completion.next_actions and completion.blockers[*].required_tool; if destination evidence is incomplete, continue the waypoint sweep rather than inventing fixture ids. Skip candidates reported as already_handled and avoid repeating work in the same stale area. When a pending_cleanup_candidates blocker is present, act only on those public candidate entries and preserve their returned waypoint identities.

Long-Horizon Eval

Long-horizon eval goals are multi-step open tasks, not whole-room cleanup sweeps. Use the operator goal to choose the source rooms and target objects. Reuse the public metric_map, observe, navigation, manipulation, and done tools only when the goal requires them. Confirm each object placement from public tool responses and finish with an empty hand when the goal requires transport. The private long-horizon grader may inspect authoritative final state, but that state and its target lists are never agent input.

Map-Build Preset

Use the same public map, observation, camera, and target-query tools, but do not run cleanup actions. Map-build waypoints are coverage candidates, not one-shot observations. When a target query, visual candidate, anchor, or waypoint observation is incomplete, use bounded public camera recovery when budget remains. If a target candidate is visible_only, needs_observe, or references a generated target-inspection candidate, convert it only through the public waypoint returned by metric_map, resolve_target_query, or tool recovery, then observe from that waypoint before calling it actionable.

A not-found map-build answer must cite the public search budget, inspected viewpoints, and any camera adjustment attempts. Call done only after the selected map-build coverage policy has generated the Runtime Metric Map and report artifacts.

Helpers

The reference cleanup routine lives at skills/household-world/scripts/trace_preserving_cleanup.py. Treat it as executable documentation for public call order and recovery shape. It is not permission to bypass MCP or read private backend state.

Use skills/household-world/scripts/target_query_recovery.py for offline review of a saved public runtime_metric_map.json. It reads only public target candidates.

Use skills/household-world/scripts/scratchpad.py when you need local memory for strategy, retries, or current intent. The scratchpad is non-authoritative. For cleanup runs, the contract-derived cleanup_worklist remains authoritative; other intents do not receive a cleanup worklist.