wrapup

/wrapup — Session Close-Out (cowork variant)

Close out the current session cleanly: review what got done, update project tracking files, emit a commit message for you to run, capture session knowledge, and confirm everything is documented. This is the "I'm done" skill — no next-session opener is produced. For passoff (future-you in a new session, or a coworker), use /aria-cowork:handoff instead.

Three modes:

• Default (/wrapup) — Per-step gated review. Each tracked surface (session summary, PROGRESS, CLAUDE.md, memory, /extract prompt) prompts for explicit confirmation before writing. The commit-message step is informational only (always emits a copy-paste block — never runs git).
• auto (/wrapup auto) — Implicit-yes on all gates. Run silently. Apply all drafts and chain /aria-cowork:extract without confirmation. The commit-message copy-paste block still emits (Cowork has no shell access to commit directly). Emit final report only. Use when the session is short and unambiguous, or when you've already authorized a combined-go (yes to all, yes to all with extract).
• snap (/wrapup snap) — Like auto, but archives the conversation via /aria-cowork:snapshot for later extraction instead of running /aria-cowork:extract now. Use when context is high: you still get the full silent close-out + commit message, but defer the expensive, compaction-risky knowledge synthesis to a later session (or the next /aria-cowork:audit-knowledge digest pass, which reads the snapshot automatically).

snap is auto plus one swap. Everywhere a step below says "If mode = auto (or snap)", snap follows auto's behavior exactly — implicit-yes, silent, apply all drafts, no per-step prompts. The single difference is the capture step (Step 8): snap runs /aria-cowork:snapshot (archive for later) while auto runs /aria-cowork:extract (synthesize now). Nothing else differs.

Cowork variant of aria-knowledge's /wrapup. Behavior is byte-aligned where Cowork's runtime permits; three divergences:

• Git commit step generates a copy-paste message instead of running git directly (Q-4 Option B — Cowork has no shell access for git status / git commit).
• Memory file updates limited to files in the attached knowledge folder. aria-knowledge reads ~/.claude/projects/.../memory/; Cowork's persistent-grant model can't reach that path.
• Tracked artifacts check (CODEMAP/STITCH staleness) skipped per ADR-005. aria-knowledge runs this in its Step 7; cowork omits.

Schema-identical outputs (PROGRESS.md entries, CLAUDE.md edits, commit message format) — only invocation and discovery paths differ.

Runtime Gate (per ADR-094)

Canonical resolution: This is the Claude Cowork variant — namespaced-only. When both plugin-claude-code and plugin-claude-cowork are loaded in the same session (most common in Claude Desktop), bare /wrapup resolves to aria-knowledge's variant — Code is the canonical owner of all 24 dual-port skills per ADR-094 §Part 1. To reach this skill, use the namespaced form: /aria-cowork:wrapup. Do NOT match bare /wrapup — that belongs to aria-knowledge.

Before Step 0: Check whether the Bash tool is available in this session. If Bash IS available (you are running in Claude Code or another runtime with shell access), surface the following notification and wait for explicit user confirmation:

⚠️ Runtime mismatch — you invoked aria-cowork's /wrapup from a runtime with shell access.

This variant emits a copy-paste commit message because Cowork has no shell access — but you appear to be in Claude Code, where git status / git commit would work directly. For the runtime-appropriate variant that runs git directly, use /wrapup (the aria-knowledge canonical).

Use /wrapup instead? (y / n)

Wait for an explicit reply:

• y / yes — Use the Skill tool to invoke wrapup (the bare-slash canonical, which routes to aria-knowledge when both ports are loaded) with the same arguments the user provided to this invocation. Do not proceed with this skill's steps; the aria-knowledge variant takes over and runs to completion. This is the default-yes path — auto-redirect is the helpful action.
• n / no — Proceed with this (aria-cowork) variant anyway despite the runtime mismatch. The user has explicitly opted in.
• No response / any other reply — Treat as "do not proceed" and exit cleanly without running either variant.

This gate applies even when mode = auto or mode = snap per ADR-094 §Part 3. Auto/snap's "implicit-yes on all gates" rule is suspended for the runtime-mismatch check — they trust that the user invoked the correct variant, and this gate enforces that precondition. All other auto/snap-mode gates remain bypassed. The friction cost is now low: on y, the auto-redirect runs the correct variant with the original args.

If Bash is NOT available (normal Cowork runtime), proceed to Step 0.

Step 0: Resolve config and parse mode

The default knowledge folder is ~/Projects/knowledge/ (expand ~ to your home directory's absolute path). Read <knowledge_folder>/aria-config.md and extract knowledge_folder. If aria-config.md doesn't exist, stop: "aria-cowork is not configured. Run /aria-setup to get started."

Parse the argument:

• No arg, or arg is empty → mode = gated (default)
• Arg matches auto (case-insensitive) → mode = auto
• Arg matches snap (case-insensitive) → mode = snap
• Any other arg → stop: "Unknown argument '{arg}'. Use /wrapup, /wrapup auto, or /wrapup snap."

Use <knowledge_folder> for all file operations during this session.

Step 1: Identify project context

Detect the active project by scanning for project markers in the attached knowledge folder OR via explicit conversation-context signals:

1. Check the attached folder structure for PROGRESS.md and CLAUDE.md files
2. Also check for CODEMAP.md (indicates a mapped codebase)
3. Check for project memory files at <knowledge_folder>/.../memory/ matching the current conversation's project context (Cowork can't reach ~/.claude/projects/.../memory/ directly — only memory files inside the granted knowledge folder are reachable)

Record:

• Project root — the directory containing PROGRESS.md and/or CLAUDE.md
• PROGRESS.md path — if it exists
• CLAUDE.md path(s) — root-level and any subfolder-level ones relevant to the session
• Memory files — any project_*.md files in the reachable memory directory for this project
• Git repos — note them in the session summary; Cowork can't run git status so detection is conversation-context based (e.g., "user mentioned they're working in the cs repo")

If no PROGRESS.md or CLAUDE.md is found, note this — the session may be in a project that doesn't use these conventions. Continue with the steps that are applicable.

Step 2: Review session work

Summarize what was accomplished in this session:

1. Work completed — files reviewed, drafts written, decisions discussed, docs read
2. Key decisions — architectural choices, design decisions, approach selections made during the session
3. Current state — what's working, what's in progress, what's blocked
4. Next steps — what the user indicated should happen next, or what logically follows

Present this summary to the user:

## Session Summary

**Project:** [project name/path]
**Focus:** [1-line description of session goal]

**Work completed:**
- [bullet list of what was done]

**Decisions made:**
- [bullet list of key decisions]

**Next steps:**
- [what follows from here]

If mode = auto (or snap): skip the prompt and proceed with the drafted summary as-is.

Otherwise (gated mode): Ask: "Does this summary look right? (yes / edit)"

If the user wants to edit, incorporate their corrections before proceeding.

Step 3: Update PROGRESS.md

If a PROGRESS.md exists for this project:

1. Read