name: conclude-it description: >- The single front door for every Claude Code session close — and the ship stage of the *-it lifecycle (plan-it plans it, build-it builds it, review-it reviews it, conclude-it concludes it). A mechanical Step-0 triage detects ship-shaped sessions (deploys run, feature work merged, DoD met without prod verification) and runs the ship pipeline first: local test gate → merge+deploy → prod gate → archive plan docs → backlog → PM board. Then the session-close core every session gets: knowledge debrief with a supersession sweep (old docs get updated or deprecated, never left "current"), session-history ledger card, mid-flight + controlled-sessions verification, idle-subagent reaping, own-footprint sweep including secrets at rest, a local CONCLUDE_REPORT.html double-check report, and an honest safe-to-exit verdict. Fail-closed gates, no fake greens. First run in a repo: a five-question setup interview (docs home, second brain + scope, deploy skill, debrief skill) saved INSIDE the repo — once per repo, global only on explicit request. Trigger on "/conclude-it", "conclude", "exit", "close this session", "wrap up and exit", "I'm done for now", "end session", "clean up before I leave", "ship it and close", or "is it safe to exit". It prepares the quit; the user types it. version: 1.1.0 license: MIT author: DevOtts author_url: https://github.com/DevOtts homepage: https://github.com/DevOtts/conclude-it repository: https://github.com/DevOtts/conclude-it metadata: platforms: [claude-code, cursor, openclaw, mcp, openai] category: "Agents & Orchestration" keywords: [session-close, ship-it, deploy-gate, prod-verification, knowledge-capture, session-debrief, cleanup, exit-ritual, claude-code, agent-skills]

/conclude-it — one door for every session close

/plan-it plans it, /build-it builds it, /review-it reviews it, /conclude-it concludes it — whether "it" is a shipped epic or an ordinary working session. Closing a long session without a ritual leaves debris: knowledge that lived only in the conversation is lost, background jobs keep running, unmerged work is stranded, finished subagents linger as RAM-holding zombies — and, worst, features get filed as "done" that were never proven in prod. This skill sequences the close so none of that survives it.

First run in a repo: a five-question setup interview (docs home, second brain + scope, deploy skill, debrief skill) — answered once, saved inside the repo, asked again only in a repo without the block. See the setup section below.

One command, two legs. Step 0 triages mechanically; the user never chooses:

• Ship-shaped session (deploys ran, feature work at the merge boundary, a Definition of Done met without prod verification, or the user said "ship it") → run the ship pipeline first, then the close core.
• Plain session (research, planning, Q&A, hygiene — the common case) → the close core only.
• Ambiguous → ask ONE question ("conclude — ship to prod — or just close?"). Never deploy on a guess.

First run in a repo — the setup interview (once per repo)

Before the first close in a repo, resolve five facts. They are per-repo memory, saved inside the repo — never global unless the user says so. Look for the block ## conclude-it — project setup in CLAUDE.md → AGENTS.md → .conclude-it/config.md; found (or derivable from existing agent instructions) → use silently. Missing → detect first (candidate docs folders, *deploy*/*debrief* skills, vault signals), then ask ONE batch of five questions, each pre-filled with what detection found:

1. Docs home — "Where is this project's documentation folder? Give me the path."
2. Second brain — "Do you keep a second brain (Obsidian or similar)? Give me the path." (or: none)
3. Second-brain scope — "Global across projects, or per-project? Explain the layout — or just say the word and I'll inspect it and guess where session knowledge should be filed." Record a guess AS a guess; propose it for approval, never silently trust it.
4. Deploy — "I use generic deploy steps by default. Create — or point me to — a <project>-deploy skill with this repo's exact instructions and I'll follow it every ship." Record the skill, or none + the recommendation; offer to scaffold it now.
5. Debrief — "Create — or point me to — a <project>-debrief skill that explains how your documentation structure works and I'll follow those guidelines." Record it; else the generic debrief flow.

Write the answers into the repo (the file it already uses — CLAUDE.md, else AGENTS.md, else create CLAUDE.md):

## conclude-it — project setup
- docs_home: docs/
- second_brain: ~/Vault/MyBrain            # or: none
- second_brain_scope: global               # global | per-project | none
- second_brain_notes: session knowledge → wiki/projects/<slug>/ (guessed — confirm)
- deploy_skill: acme-deploy                # or: none (recommended: create acme-deploy)
- debrief_skill: acme-debrief              # or: generic
- configured: YYYY-MM-DD

If the user explicitly says "save this globally", ALSO write the answers as user-level defaults; per-repo blocks always override. Consumers: the debrief step runs debrief_skill against docs_home; the ledger card mirrors to the second brain only when its scope says global; the ship pipeline deploys via deploy_skill — none values degrade inline and the verdict repeats the create-a-skill recommendation once.

The ship pipeline (ship-shaped sessions only)

Fail-closed, in order. (The Claude Code plugin carries an expanded version in references/ship-pipeline.md, loaded only when triage says ship-shaped; this file is self-contained — on any other agent, run the steps below as written.)

1. S0 Scope + rename — name the epic in one line; rename the session done-<name>.
2. S1 Local gate — run the project's REAL test/e2e scripts (dead placeholder scripts are never gate targets). RED → diagnose→fix→re-run via /iterate until green; a red local gate never proceeds to prod. No runnable suite? say "unverified", don't manufacture a pass.
3. S2 Merge + deploy — merge hygiene per repo (never strand unmerged work), then the project's own deploy skill/path. Irreversible destructive steps still need an explicit yes.
4. S3 Prod gate — smoke/e2e against prod. RED → fix, re-deploy, re-verify. No reachable prod target → close as "deployed-but-unverified", loudly.
5. S4 Archive — git mv the epic's plan docs to their home's 0-done/ sibling; fix links.
6. S5 Backlog — write deferred follow-ups where the next session will look, each note naming the originating session.
7. S6 PM board — flip the epic's rows on the project's tracker, if one exists.

The session-close core (every session)

1. Confirm intent — one line on what's about to happen.
2. Debrief — run the project's session-debrief (a generic one is bundled) so patterns/gotchas/decisions land in durable docs. Skip-if-done guard (check artifacts, not memory). Require the supersession line: a session that changed behaviour must show old docs updated or status: deprecated — never two "current" docs describing two versions of the same feature.
3. Ledger card — a ≤40-line OKR-style card (objective, honest key results, files touched, pointers, next) into <repo>/.agents/history/ + INDEX row; every session gets one, so "which session did X?" stays answerable for ~150 tokens instead of a transcript distillation.
4. Mid-flight check — background tasks, unmerged/uncommitted work, live server-side jobs, and sessions THIS session orchestrated (peers, headless spawns): each must be terminal or handed to the user by name. Never exit an orchestrator with a worker running unowned.
5. Reap — stop finished subagents once their output is captured in files; kill lingering headless processes by exact recorded PID only (never a pattern-matched kill).
6. Footprint sweep — remove what this session created and nothing references: worktrees, landed branches, remote/pod files, scratch. Secrets at rest are swept FIRST and verified absent. Clean only what you can prove you created; report the rest. Keep config backups and anything a durable doc cites.
7. CONCLUDE_REPORT.html (ship sessions) — a local, deterministic HTML double-check report (manifest + bundled build-report.py + template: light/dark toggle, badge cards, per-item "How to test" blocks, embedded markdown reports). RED/UNVERIFIED items get their own badge — a report that only shows the green half is a fake.
8. Verdict — ✅ safe to exit (with what was cleaned, what was deliberately left and why, and that no written credential is still at rest) or ⚠️ not yet (the specific blocker + the choice). Then STOP — the user types the quit.

What it never does

• Advance past a red gate, skip a gate for a faster close, or report GREEN off a mock/skipped suite/targetless prod check.
• Deploy on a guess, or run irreversible destructive prod steps without an explicit yes.
• Re-run a debrief that already ran; skip the ledger card; glob-delete in shared locations; delete what a durable doc cites.
• Quit the process itself — it prepares the exit, the user takes it.

Portability — graceful degradation outside Claude Code

This file is the complete, self-contained ritual: it runs on any SKILL.md-compatible agent (Cursor, Codex CLI, Copilot, OpenCode, Windsurf, Gemini CLI, and 70+ others via the Agent Skills standard). Some helpers it names are Claude Code plugin pieces; when one is absent, degrade inline and say so — never skip the step and never pretend the helper ran:

• /iterate / /full-qa absent → run the diagnose→fix→re-test loop and the e2e/smoke verification yourself, inline. The gates and their fail-closed rules are unchanged.
• Report machinery absent (build-report.py + template ship only in the plugin) → write CONCLUDE_REPORT.md (markdown) with the identical structure: gates scoreboard first, per-item sections with status + "How to test" steps, RED/UNVERIFIED first-class.
• Bundled session-debrief absent and the project has no debrief skill → capture inline: dated session-log entry in the project's docs + the promotion/supersession sweep from the debrief spec (update durable pages, bump their verified-date, deprecate what the change replaced).
• No subagent/rename primitives on this harness → do the work in the main loop and emit the rename line for the user; the sweeps and verdict still run.

Whatever ran inline gets named in the verdict ("debrief ran inline — no debrief skill installed"), so the close is honest about its own machinery.

Install

Claude Code (plugin, recommended — full bundle: ship-pipeline reference, HTML report machinery, bundled session-debrief):

/plugin marketplace add DevOtts/conclude-it
/plugin install conclude-it@devotts

Any SKILL.md-compatible agent (Cursor, Codex CLI, Copilot, OpenCode, Windsurf, …):

npx skills add DevOtts/conclude-it -a <agent>    # peek first: npx skills add DevOtts/conclude-it --list
gh skill install DevOtts/conclude-it             # GitHub CLI alternative

Getting started: at the end of any working session —

/conclude-it

Plain sessions get the close core (debrief → ledger card → verification → reap → sweep → verdict). Sessions that shipped get the full ship pipeline first — gates, deploy, prod verification, archive — and a local CONCLUDE_REPORT.html you open in the browser to double-check everything with "How to test" steps per item.

Security considerations

• Secrets-at-rest sweep: the footprint step explicitly hunts credentials the session wrote to disk, remote hosts, or pods — removes them and verifies absence rather than trusting the delete.
• Exact-PID kills only: lingering processes are killed by the exact recorded PID, never by pattern match — a grep-kill can take out another session's work.
• Proven ownership: the sweep deletes only what the session can show it created; everything else is reported, never touched.
• Deploy authorization is scoped: invoking the ship path authorizes the deploy sequence, but irreversible destructive actions (data-dropping migrations, volume deletion) always require an explicit yes.
• No hosted publishing: the closeout report is a local file; nothing is published to hosted surfaces uninvited.

Authored by DevOtts.

[!NOTE] The lifecycle family — plan-it plans it, build-it builds it, review-it reviews it, conclude-it concludes it: plan-it plans → build-it builds → review-it verifies → conclude-it concludes. This is the last stage: the work is built and reviewed; conclude-it ships it, proves it in prod, files the knowledge, cleans the debris, and closes the session. (prompt-it compiles the prompts that start it all.)

Every long agent session ends the same way: you type the quit and hope. Hope the knowledge that existed only in the conversation got written down somewhere. Hope the feature you merged actually works in prod. Hope no background job is still running, no worktree is left dangling, no credential got echoed into a file on a remote host at 2am.

conclude-it replaces the hope with a ritual. One command, every close. A mechanical triage looks at what the session actually did — deploys run, feature work at the merge boundary, a Definition of Done met without prod verification — and picks the leg for you:

• Ship-shaped session → the ship pipeline first: local test gate → merge + deploy → prod gate → archive the plan docs → capture the backlog → update the board. Fail-closed: a red gate never proceeds, and a skipped gate is a failed gate.
• Plain session (research, planning, Q&A — the common case) → straight to the close core.

Then every session, both legs, gets the same close core: debrief the knowledge into durable docs, write the session-history ledger card, verify nothing is mid-flight, reap idle subagents, sweep the session's own footprint (secrets at rest first), and end with a verdict you can trust.

Why a close ritual

Because the failure modes of ending a session are quieter than the failure modes of running one — and they compound:

The honest claim: conclude-it doesn't make your tests pass or your deploy work. It makes it impossible to close a session on top of a failure without seeing it named.

Installation

conclude-it ships as both a Claude Code plugin and a standard repo-root SKILL.md, so it installs across the whole agent ecosystem. Pick your tool below.

[!TIP] Two universal installers understand the SKILL.md standard and drop conclude-it into the right directory for 70+ tools — use these if your agent isn't listed:

npx skills add DevOtts/conclude-it -a <agent>   # e.g. -a codex, -a cursor, -a github-copilot ; add -g for global
gh skill install DevOtts/conclude-it            # GitHub CLI (project or user scope)

Peek first with npx skills add DevOtts/conclude-it --list.

Claude Code · native, full experience

# 1. Register the marketplace
/plugin marketplace add DevOtts/conclude-it

# 2. Install the plugin (plugin-name@marketplace-name)
/plugin install conclude-it@devotts

The marketplace name devotts comes from the name field in marketplace.json. This is the only target that gets the full bundle — the conductor with its progressive-disclosure ship pipeline, the deterministic build-report.py + HTML template machinery, and the bundled generic session-debrief, with slash-command invocation and auto-activation. (Skills-CLI alternative: npx skills add DevOtts/conclude-it -a claude-code.)

Codex · OpenAI Codex CLI

npx skills add DevOtts/conclude-it -a codex
# or:  gh skill install DevOtts/conclude-it

Installs to the shared .agents/skills/conclude-it/ that Codex reads. Codex doesn't carry the bundled machinery, so conclude-it runs the debrief inline and writes the closeout report as markdown (graceful degradation) — you still get the triage, the fail-closed gates, the ledger card, the sweeps, and the honest verdict.

OpenClaw

npx skills add DevOtts/conclude-it -a openclaw

Lands in .openclaw/skills/conclude-it/SKILL.md.

Cursor

npx skills add DevOtts/conclude-it -a cursor      # add -g for a global install

Installs into Cursor's .agents/skills/ and is auto-discovered.

VS Code + GitHub Copilot

npx skills add DevOtts/conclude-it -a github-copilot
# or:  gh skill install DevOtts/conclude-it

Copilot auto-discovers skills under .agents/skills/.

Copilot CLI

gh skill install DevOtts/conclude-it
# or:  npx skills add DevOtts/conclude-it -a github-copilot

Kiro CLI / IDE

gh skill install DevOtts/conclude-it

If your Kiro build doesn't yet read the shared skills path, drop the skill in manually:

git clone https://github.com/DevOtts/conclude-it /tmp/conclude-it
mkdir -p "<kiro-skills-dir>/conclude-it" && cp /tmp/conclude-it/SKILL.md "<kiro-skills-dir>/conclude-it/"

Others · OpenCode · Cline · Windsurf · Zed · Gemini CLI · Antigravity · Amp · Warp …

npx skills add DevOtts/conclude-it -a <agent>

Run npx skills add DevOtts/conclude-it --list, then target your agent — the CLI knows the correct path for each. Manual fallback for any tool: clone the repo and copy the root SKILL.md into your agent's skills/instructions directory.

[!NOTE] On every target except Claude Code, conclude-it installs as a single self-contained skill (the root SKILL.md — it carries the full flow, ship pipeline included). The HTML report machinery, the bundled session-debrief, and delegated helpers like /iterate and /full-qa are Claude Code plugin pieces; elsewhere conclude-it runs those phases inline, writes the closeout report as markdown, and names the absence in its verdict instead of pretending. The thing that ports everywhere is the ritual — the gates, the sweeps, and the honesty.

Use

/conclude-it        # at the end of any session — the triage picks the leg

Also answers to plain language: "close this session", "wrap up and exit", "ship it and close", "I'm done for now", "is it safe to exit?".

First run — conclude-it interviews your repo (once)

The first time you close a session in a repo, conclude-it runs a five-question setup interview — and it detects before it asks, so most questions arrive pre-answered for you to confirm:

1. Where is your documentation folder?
2. Do you keep a second brain (Obsidian or similar)? Path?
3. Is it global or per-project? Explain the layout — or just say the word and it inspects the vault and proposes where session knowledge should be filed (a guess is always labeled as a guess, never silently trusted).
4. Deploy — it recommends you create (or point it to) a <project>-deploy skill with this repo's exact deploy instructions, and offers to scaffold it from what it already knows. Until then, deploys run inline via your documented path.
5. Debrief — same shape: a <project>-debrief skill describing how your docs structure works; otherwise the bundled generic session-debrief.

The answers are saved as a small block inside the repo (CLAUDE.md /