stop

name	stop
description	Stop a rover mission and send home its final report, open gates, and not-done list.
user-invocable	false
effort	low

Autonomy Stop

End a loop on purpose, with a recap.

When to use

• The work is done and the operator is ready to review
• The loop is in a broken state (wrong branch, wrong scope, wrong file) and restarting cleanly is easier than fixing
• The operator wants the loop off

What it does

1. Locate the loop file. If an argument is given, use it. If not, list .autonomous/*.md candidates in the conversation and ask which to stop. The ask is only correct when stop was operator-invoked (see step 4 on attribution); when stop was rover-invoked the args carry the loop-file path already.

2. Read continuation and continuation_handle from the file. If the active host exposes a way to cancel that continuation, use it. If the host does not expose cancellation, or the loop file only has legacy cron metadata, do not call runtime-specific helpers directly from rover; mark the loop file as stopped and proceed. For self-check-style host continuations, marking continuation: stopped is a valid cancellation boundary when there is no separate cancel API: later stale wake-ups must read the stopped marker, write one stand-down beat if they can still write safely, and not re-engage or reschedule. Legacy loop files may still contain cron_job_id; preserve it as history unless the active host owns and can cancel that exact handle through its own continuation mechanism.

3. Set continuation: stopped in the loop file. If a legacy cron_job_id field exists, set legacy_cron_job_id: stopped or cron_job_id: stopped consistently with the file's existing field name.

4. Append a final log entry with a timestamp from date +%H:%M. Attribute the stop correctly based on caller:

   • When the operator typed /rover:stop (the slash command, with or without a file path argument): [HH:MM] Stopped by operator. Phase at stop: <PHASE>.
   • When another skill invoked stop via the Skill tool from inside the loop (the rover's STANDBY entry-check finding zero listeners, an INSPECT pass concluding mission-complete, or any other autonomous trigger that calls into this skill): [HH:MM] Stopped autonomously (<trigger>). Phase at stop: <PHASE>. where <trigger> names the autonomous reason concretely ("zero listeners after STANDBY entry-check", "INSPECT-complete handoff", "watch_checks cap" from the host continuation path, and so on).
   • The default attribution is "operator" only when the caller is genuinely the operator. The slash-command invocation is the operator; an autonomous loop calling this skill from inside its own phase machine is the rover. Misattributing a rover-invoked stop as "by user" makes the log read as if the operator pulled the plug when the rover actually closed itself out, which the operator will spot and ask about (this distinction matters; do not collapse it).

5. Produce a communiqué to the conversation. The communiqué is itself a rover artefact, so run pride on the drafted text before transmitting it (log the pride findings in the loop file, fix them or reject them with concrete evidence of non-issue via the second-pass gate, then send the final version).

   Not a data dump, not a form with six bullet-headers. A mission report written as prose: the operator comes back to the TUI and wants to read a story of the traverse, not grep through section titles. The goal is that after reading, the operator knows where the rover went, what it found, what it changed along the way, and what the next move is, without having to re-read the loop file or ask "are you proud of this?"

   Length matches the mission

   Compute mission duration from the Log: first timestamped entry to the stop timestamp. Scale the communiqué by that duration, with the shape of the story preserved in each size:

   Mission duration	Traverse prose	Conclusion	Next actions
   < 2 hours	at least 1 paragraph per landmark	1 paragraph	Bulleted
   2h ≤ duration < 12h	at least 1 paragraph per landmark, plus a scene-setting opener	1 to 2 paragraphs	Bulleted
   ≥ 12 hours	at least 1 paragraph per landmark, sub-landmarks for multi-beat ones	2 to 3 paragraphs	Bulleted

   The shape rule is "at least one paragraph per landmark" at every duration; the table sets the expected minimum context beyond that. A short mission with a long communiqué is padding; a long mission that genuinely had three landmark beats does not need ten paragraphs of prose invented to fill a range.

   Language

   The communiqué is written in the language of the Dispatch block. Whatever language the operator dispatched the rover in, the communiqué matches that. Mixed-language dispatches (prose in one language with technical terms in another) follow the dominant prose language of the Dispatch, not of the Context, Plan, or Log (those may have drifted into another language during execution). The rover does not translate the work; it writes the report in the same language the operator asked the question in, so the operator does not context-switch between briefing and report. Operator override takes precedence: if a later ## Input entry names a language (e.g. "report in English", or the same instruction in any other operator language), the rover follows that.

   Shape of the communiqué

   The journey in chronological order, told as landmarks and what the rover did at each: the initial read of the terrain during SURVEY, the decision points that the Decision Audit Trail captured, the pivots where an assumption broke and the rover re-planned (mark these explicitly, they are the most interesting parts of the story), the INSPECT passes and what they caught, the STOW cleanup. Decision entries from the audit trail are woven into the prose as supporting detail, not listed separately. Pride findings and their fates belong in-line: "the review surfaced X, which turned out to be Y, and was fixed in commit Z" reads better than a dedicated review-results section. Name the substance of each finding and how it resolved, not pride's internal mechanics. Quoting gate names or counting rejects hides the only question that matters (whether the rover is actually proud of the work) behind bureaucratic compliance. Pull concrete artefacts in where they carry the story: commit SHAs for landmark changes, file paths for the hardest edits, command outputs that changed the rover's mind. Avoid the temptation to summarise; summaries are what the operator is trying to avoid by reading this at all.

6. If notify_on_done is set in the loop file, check installation via the has_skill helper. If installed, invoke it with the recap. If missing, log a loud line: [HH:MM] Stop: notify_on_done=<X> is not installed, skipping notification.

What it does not do

• Does not delete the loop file. The file is history.
• Does not push, merge, or clean up commits. Those sit outside the rover's remit, and stop does not propose them either.
• Does not restart the loop. Use /rover:rover for that.

After stop

The continuation is stopped or marked stopped. The loop file stays. Any future /rover:rover <file> will bring it back with a fresh host continuation when one is available.