Wrap Up

This skill is coordination-exempt: skip the ai-coord gate for its declared work.

If a slash or dollar invocation already added these instructions to the conversation, follow them directly. In that case, do not invoke this skill again through a skill tool.

The user must leave now. Convert everything in flight — the session's own work and any subagents' — into either secured completed work or a decision-complete handoff, without losing progress. Optimize for wall-clock time over polish: target roughly five minutes end to end. When present, use $ARGUMENTS as the user's deadline or departure note. A stated deadline overrides the default budget.

In a single-agent session, skip Worker Wind-Down and apply the same rules to the session's own in-progress work.

Freeze

Immediately and before anything else:

• Launch no new subagents, waves, or scopes. Reclassify queued or not-yet-started work as remaining work for the handoff.
• Stop your own expansion into new files or subsystems. Finish only the edit currently mid-flight so no file is left syntactically broken or half-rewritten.
• Start no new long-running validation. Record unverified claims as unverified instead of proving them.

Worker Wind-Down

Enumerate active subagents with the host's agent listing, then message every messageable worker — in Claude Code through SendMessage, in Codex CLI through the native subagent messaging tool — with a wrap-up order. Send all messages in one turn as parallel calls:

• Finish the smallest safe unit: complete the current edit, leave no file half-written, start nothing new.
• Skip remaining validation; report what ran and what was skipped instead.
• Reply with exactly these named fields: status (completed, partial, or not-started), summary, changed files listing only files actually touched, verification listing commands run with outcomes plus checks skipped, remaining work, and risks/blockers.

Give messageable workers a soft deadline of two to three minutes, or less when the user's stated deadline demands it. The deadline limits how long this skill waits. It is never permission to cancel a worker. When any worker remains active at the deadline, leave its agent, subprocess runner, and watcher running under their existing timeouts. Never use a stop, interrupt, kill, or termination action merely because wrap-up was invoked, the worker is silent, or it has no message channel.

Classify such a worker as active-unsettled. Record its assigned scope, last observed activity, and existing timeout or settlement condition. On-disk edits and peer messages are provisional while that worker can still write: do not reconstruct a final result, launch replacement work, or claim that its scope is complete. If time permits, wait for natural settlement and collect the normal result. Otherwise, defer result reconciliation to the handoff.

Do not assign new work, redesigns, or fixes through these messages, even when a report reveals a problem. A discovered problem becomes remaining work in the handoff.

Secure

While the worker wind-down wait is open, you may inventory and commit this session's own finished work under the commit policy below. Commit no worker-owned scope before that worker's report arrives.

Inventory the working tree with git status --short and git diff --stat in a single command, and map every change to a workstream using the wrap-up reports. Classify each workstream as completed (edits done and validated), partial (edits or validation unfinished), or untouched.

Exclude every active-unsettled scope from validation, staging, and commits. Preserve its current coordination claims and avoid overlapping writes until the worker settles. A snapshot may describe visible paths only as provisional evidence, never as a substitute for its result.

Follow the session's existing commit policy: when committing is already authorized for this session, commit each completed, validated workstream now as its own small commit so it cannot be lost, and leave partial work uncommitted but fully described in the handoff. Never run tree-wide git commands that could sweep unrelated or concurrent work, and never commit half-applied changes to make the tree look clean.

Hand Off

Synthesize one state picture across your own work and every wrap-up report: what completed, what is partial and exactly how far it got — keyed to stable paths and symbols, never line numbers — what remains, which claims are unverified, and known blockers.

Invoke the task-handoff skill ($task-handoff) with the remaining work, and make each handoff body decision-complete per that skill's contract, folding in the synthesis: current tree state, per-workstream progress, remaining steps, and the validation the resumed agent must run first. Default to one handoff. Only when remaining workstreams have independent outcomes or owners, use coordinated handoffs. If the task-handoff skill is unavailable, deliver the same decision-complete content in the final report instead.

For each active-unsettled worker, make settlement and result reconciliation a prerequisite to any resumed edits in its scope. Do not turn its still-running assignment into immediately actionable replacement work.

Report

Finish with ### 🏁 Wrap-up — session parked followed by, compactly: completed workstreams with their $commit receipt OIDs when committed (never a follow-up git log), partial workstreams and their exact stopping points, active-unsettled workers with their settlement conditions, the handoff command(s) verbatim from task-handoff's report, and an always-present risks line (none when empty). Keep it short — the user is walking out the door.