cc-codeconductor 0.5.0 → 1.1.0

package/presets/claude/commands/cc/backlog.md

@@ -0,0 +1,104 @@
+---
+description: >-
+  [cc: alias] Author BACKLOG.md — wayfinding, grilling, create or append items,
+  validate with openspec, and plan OpenSpec change folders for /cc:openspec.
+---
+
+# Backlog Authoring Workflow
+
+Objectives: $ARGUMENTS
+
+Create or append valid `BACKLOG.md` items and OpenSpec change docs. Do **not**
+deliver implementation — that is `/cc:openspec`.
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `backlog` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command backlog "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command backlog "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile backlog --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command backlog --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Wayfinding (Repo Explorer role)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (and
+`graphify path` / `graphify explain` when needed). Then adopt the **Repo
+Explorer** role. Do not write `BACKLOG.md` in this step. Record a Repo Map so
+Scope names real files or modules.
+
+---
+
+## Step 2 — Relentless Grilling (Task Coach role)
+
+Adopt the **Task Coach** role. Produce complete backlog item fields: title,
+type, risk, scope, description, out of scope, measurable acceptance criteria.
+
+Every assumption must survive one grilling question. Reject vague acceptance
+("improve UX", "fix bugs").
+
+If any field is missing or ambiguous, ask one clarifying question at a time.
+
+**STOP here.** Unresolved grilling questions populate `questionsForUser` in the
+CCEP-1 `planner-output`; `ccep evaluate --command backlog` halts until a human
+answers. Do not write `BACKLOG.md` until that confirmation.
+
+---
+
+## Step 3 — Write or append BACKLOG.md (Docs role)
+
+Apply skill `backlog`.
+
+- If `BACKLOG.md` is absent, create it from the canonical template. Set Global
+  `Product` from `package.json` `name` when present.
+- If it exists, append new `### BC-xxx` items under `## Items`. Do not rewrite
+  `## Global` or `## Archive`.
+- Next ID = max `BC-NNN` across Items and Archive, plus one.
+- New items: Status `READY`, Progress `0%`, measurable Acceptance checklist.
+
+Do **not** `git add` `BACKLOG.md` or `openspec/`.
+
+---
+
+## Step 4 — Validate (mandatory gate)
+
+Run:
+
+```bash
+npx cc-codeconductor openspec validate
+```
+
+If validation fails:
+
+1. List all errors and recommendations from the CLI output.
+2. Show the canonical BACKLOG.md structure (## Global, ## Items, ### BC-001 | Title, Priority, Status, Type, Depends on, Description, Scope, Acceptance).
+3. Fix the file and re-run validate. **STOP** planning until valid.
+
+---
+
+## Step 5 — Plan new items
+
+For each **new** `BC-xxx` from this run:
+
+```bash
+npx cc-codeconductor openspec plan <BC-id>
+```
+
+Show TaskCards and `openspec/changes/<slug>/` (proposal, design, tasks, specs).
+
+---
+
+## Completion
+
+Report: item IDs added, validate result, change folder paths.
+
+Tell the user to run `/cc:openspec` (optionally `/cc:openspec BC-xxx`) to
+deliver. Do not start delivery in this workflow.
+
+Apply skill `backlog` for create/append rules. Apply skill `openspec` only for
+format and state-machine reference.

package/presets/claude/commands/cc/clarify.md

@@ -0,0 +1,32 @@
+---
+description: >-
+  [cc: alias] Re-explain the last deliverable in Task Card vocabulary when it did not land.
+---
+
+# Clarify Workflow
+
+Clarify request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `clarify` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command clarify "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command clarify "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile clarify --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command clarify --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Re-explain (task-coach)
+
+Invoke `task-coach` / `orchestrator`. Restate the last Task Card, plan, or review in the project's vocabulary. Do not add new scope. If questions remain, one question per branch.
+
+**STOP if ConfirmationGate reports questions.**
+
+---
+
+## Completion
+
+A plain-language restatement plus any remaining questions. Then resume the previous workflow.

package/presets/claude/commands/cc/council.md

@@ -0,0 +1,87 @@
+---
+description: Council-driven workflow with CCEP-1 bootstrap
+---
+
+# Council-Driven Workflow
+
+Task request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `council` (fixed for this workflow — do not infer from user text)
+command: council
+
+1. Run: `npx cc-codeconductor ccep parse --command council "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command council "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile council --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command council --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map impact radius before deliberation. Do not write code in this step.
+
+---
+
+## Step 2 — Deliberation & Specification (SDD)
+
+Invoke the `council` skill to analyze the request before writing any code. The council must act as a steering committee involving `task-coach` (Product), `architect`, and `devil`.
+
+The council must:
+1. Clarify the prompt and define the absolute minimum scope (Simplicity Gate).
+2. Explicitly document all assumptions and run the Grilling protocol on each one (Think Before Coding).
+3. Draft a Task Card & Technical Plan (The Specification).
+
+**STOP here.** Unresolved grilling questions populate `questionsForUser` in the
+CCEP-1 `planner-output`; `ccep evaluate` (ConfirmationGate) halts until a human
+answers. Show the agreed Task Card & Technical Plan and wait for confirmation
+before continuing.
+
+---
+
+## Step 3 — Test Definition (TDD)
+
+Invoke `tester` with the approved Task Card & Technical Plan.
+
+tester must:
+1. Write failing tests based on the Acceptance Criteria defined in the Task Card.
+2. Confirm the tests fail as expected (Red state).
+
+**Goal-Driven Execution (Karpathy)**: Do not proceed until verifiable tests are written and fail for the correct reasons.
+
+---
+
+## Step 4 — Surgical Implementation
+
+Invoke `implementer` with the failing tests and the Technical Plan.
+
+implementer must:
+1. Write the minimal code required to pass the tests.
+2. Touch ONLY the files specified in the Technical Plan (Surgical Changes).
+3. NOT refactor adjacent code, change existing styles, or build speculative features.
+4. Run the tests. Loop `implementer` -> `tester` until all tests pass (Green state).
+
+---
+
+## Step 5 — Multi-Perspective Council Review
+
+Invoke the `council` skill on the generated diff to perform the final review phase.
+
+The council will evaluate the diff against the 6 axes (Architecture, Security, Product, Delivery, DataOps, Devil).
+
+If ANY agent votes CRITICAL (especially due to over-engineering, scope creep, or missing the verifiable goals):
+- The Review Report status is **BLOCKED**.
+- Return to Step 4 with the feedback.
+
+If APPROVED (no CRITICAL findings):
+- Deliver the final Council Verdict and the diff summary.
+
+---
+
+## Completion
+
+Deliver the complete Council Verdict. The feature is only complete when tests pass and the council explicitly approves the implementation according to the specification.

package/presets/claude/commands/cc/db-migration.md

@@ -8,6 +8,19 @@ description: >-
 
 Migration request: $ARGUMENTS
 
+## Step 0 — CCEP Bootstrap
+
+Command: `db-migration` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command db-migration "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command db-migration "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile db-migration --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command db-migration --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
 ## Step 1 — Task Card validation (Task Coach role)
 
 Adopt the **Task Coach** role as defined in `CLAUDE.md`.
@@ -31,22 +44,22 @@ rollback/forward-fix notes, and test approach.
 
 ---
 
-## Step 3 — Implementation (Implementer role)
+## Step 3 — Migration Tests (Tester role)
 
-Adopt the **Implementer** role as defined in `CLAUDE.md`.
+Adopt the **Tester** role as defined in `CLAUDE.md`.
 
-Keep model and migration changes together, avoid unrelated refactors, and
-preserve the deployment order specified by architect.
+Cover migration-sensitive behavior where the stack supports it, including
+existing-data edge cases and rollback/forward-fix notes when automated rollback
+tests are not practical.
 
 ---
 
-## Step 4 — Migration Tests (Tester role)
+## Step 4 — Implementation (Implementer role)
 
-Adopt the **Tester** role as defined in `CLAUDE.md`.
+Adopt the **Implementer** role as defined in `CLAUDE.md`.
 
-Cover migration-sensitive behavior where the stack supports it, including
-existing-data edge cases and rollback/forward-fix notes when automated rollback
-tests are not practical.
+Keep model and migration changes together, avoid unrelated refactors, and
+preserve the deployment order specified by architect.
 
 ---
 

package/presets/claude/commands/cc/explore.md

@@ -0,0 +1,36 @@
+---
+description: >-
+  [cc: alias] Map the repository and recommend the next CodeConductor slash command. Read-only.
+---
+
+# Explore Workflow
+
+Explore request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `explore` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command explore "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command explore "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile explore --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command explore --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Map (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"`. Invoke `repo-explorer`. Produce a Repo Map. Do not write code.
+
+---
+
+## Step 2 — Suggest next command (orchestrator)
+
+Recommend exactly one next slash command (`/cc:feature`, `/cc:fix`, `/cc:refactor`, `/cc:review`, `/cc:backlog`, `/cc:openspec`, `/cc:triage`, …) with a one-sentence rationale. Do not start that workflow.
+
+---
+
+## Completion
+
+Report the Repo Map and the recommended next `/cc:` command.

package/presets/claude/commands/cc/feature.md

@@ -10,22 +10,49 @@ Feature request: $ARGUMENTS
 
 ---
 
-## Step 1 — Task Card validation (Task Coach role)
+## Step 0 — CCEP Bootstrap
+
+Command: `feature` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command feature "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command feature "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile feature --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command feature --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map modules, conventions, and impact radius. Do not write code in this step.
+Record a Repo Map artifact before intake.
+
+---
+
+## Step 2 — Task Card validation (Task Coach role)
 
 Adopt the **Task Coach** role as defined in `CLAUDE.md`.
 
 Produce a complete Task Card. The Task Card is ready when it contains: title,
-type, risk classification, scope, context, acceptance criteria, and constraints.
+type, risk classification, scope, context, acceptance criteria, and
+constraints, and every assumption behind it has survived one grilling
+question (Grilling protocol).
 
 If any field is missing or ambiguous, ask one clarifying question at a time and
 wait for the answer. Do not proceed with an incomplete Task Card.
 
-**STOP here. Show the completed Task Card and wait for human confirmation before
-continuing.**
+**STOP here.** Unresolved grilling questions or missing fields populate
+`questionsForUser` in the CCEP-1 `planner-output`; the `ConfirmationGate`
+(`ccep evaluate`) reads that field and halts the workflow until a human
+answers. Show the completed Task Card and wait for that confirmation before
+continuing.
 
 ---
 
-## Step 2 — Technical Plan (Architect role)
+## Step 3 — Technical Plan (Architect role)
 
 Adopt the **Architect** role as defined in `CLAUDE.md`.
 
@@ -43,7 +70,20 @@ not proceed to implementation until the plan is approved.**
 
 ---
 
-## Step 3 — Implementation (Implementer role)
+## Step 4 — Test coverage (Tester role)
+
+Adopt the **Tester** role as defined in `CLAUDE.md`.
+
+Use the Implementation Summary and the Task Card.
+
+1. Write or extend failing tests for the new behavior before implementation (RED).
+2. Ensure all acceptance criteria from the Task Card have at least one test.
+3. Run the full test suite and confirm it passes.
+4. Produce a Test Report: test files added or modified, cases covered.
+
+---
+
+## Step 5 — Implementation (Implementer role)
 
 Adopt the **Implementer** role as defined in `CLAUDE.md`.
 
@@ -52,26 +92,13 @@ Implementer creates a Git Worktree before touching any file; all edits happen in
 
 1. Read the Technical Plan before touching any file.
 2. Apply the minimal diff — only what the plan specifies.
-3. Run the project test suite after implementation.
+3. Run the project test suite and make the previously written failing tests pass.
 4. Produce an Implementation Summary: what changed, which files, how to verify
    locally.
 
 ---
 
-## Step 4 — Test coverage (Tester role)
-
-Adopt the **Tester** role as defined in `CLAUDE.md`.
-
-Use the Implementation Summary and the Task Card.
-
-1. Write or extend tests to cover the new behavior.
-2. Ensure all acceptance criteria from the Task Card have at least one test.
-3. Run the full test suite and confirm it passes.
-4. Produce a Test Report: test files added or modified, cases covered.
-
----
-
-## Step 5 — Code review (Reviewer role)
+## Step 6 — Code review (Reviewer role)
 
 Adopt the **Reviewer** role as defined in `CLAUDE.md`.
 
@@ -85,7 +112,7 @@ they are resolved and the diff is re-reviewed.
 
 ---
 
-## Step 6 — Documentation (Docs role)
+## Step 7 — Documentation (Docs role)
 
 Adopt the **Docs** role as defined in `CLAUDE.md`.
 

package/presets/claude/commands/cc/fix.md

@@ -18,7 +18,29 @@ Provide the following information in $ARGUMENTS:
 
 ---
 
-## Step 1 — Task Card validation (Task Coach role)
+## Step 0 — CCEP Bootstrap
+
+Command: `fix` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command fix "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command fix "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile fix --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command fix --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map modules, conventions, and impact radius. Do not write code in this step.
+Record a Repo Map artifact before intake.
+
+---
+
+## Step 2 — Task Card validation (Task Coach role)
 
 Adopt the **Task Coach** role as defined in `CLAUDE.md`.
 
@@ -32,11 +54,43 @@ Produce a Task Card that includes:
 If reproduction steps are missing, ask for them before classifying risk. A bug
 without a reproduction path cannot be classified reliably.
 
+Capture evidence before tests: reproduction, logs or stack traces, and one
+falsifiable hypothesis of the root cause. Do not patch without that evidence.
+Redact secrets, tokens, and credential dumps from logs before they enter the
+Task Card. Summarize stack traces; do not paste env files.
+
 **STOP here. Show the Task Card and wait for human confirmation.**
 
 ---
 
-## Step 2 — Route by risk
+## Step 2.5 — Red loop gate
+
+Before hypothesizing about the root cause, produce a reproduction command:
+one deterministic, tight command that exercises the real bug path and asserts
+the exact symptom the user reported (not a proxy or a related error).
+
+Requirements:
+
+- The command must be **deterministic** — running it twice produces the same
+  result.
+- The command's assertion must match the exact user-reported symptom (actual
+  vs. expected from the Task Card), not a generic failure.
+- Run it at least once before continuing. Do not proceed to Step 3 until you
+  have run it and it reproduces the bug (RED).
+
+Record the run as evidence so `cc verify` can see it: write a JSON file to
+`.codeconductor/evidence/` matching `EvidenceSchema` with `type: 'test'` and a
+`data` payload shaped like `ImplementerTestsSchema` (`runner`, `result`,
+`failedTests`), e.g. `{ "runner": "<reproduction command>", "result": "failed" }`
+for this red run. After the fix (Step 3/4a/4b), re-run the same command and
+update the evidence to `"result": "passed"` — `cc verify --task <id>` reads
+this evidence directly, no code changes required.
+
+**Do not proceed to Step 2 without a reproduction command that has been run.**
+
+---
+
+## Step 3 — Route by risk
 
 Read the risk field from the Task Card and follow the corresponding route.
 
@@ -45,16 +99,16 @@ Read the risk field from the Task Card and follow the corresponding route.
 Applies when: the bug is isolated to a single component, existing tests cover
 the affected code, and no public API or shared state is involved.
 
-Route: Task Coach → Implementer → Tester
+Route: Task Coach → Tester → Implementer
 
-Proceed directly to Step 3a.
+Proceed directly to Step 3 (tests), then Step 4a.
 
 ### Medium or high-risk route
 
 Applies when: the bug touches shared state, a public API, auth or payment paths,
 database writes, or the root cause is not yet understood.
 
-Route: Task Coach → Architect → Implementer → Tester → Reviewer
+Route: Task Coach → Architect → Tester → Implementer → Reviewer
 
 Adopt the **Architect** role before implementation. Architect must:
 
@@ -68,19 +122,30 @@ before continuing.**
 
 ---
 
-## Step 3a — Implementation, low-risk (Implementer role)
+## Step 4 — Regression tests (Tester role)
+
+Adopt the **Tester** role as defined in `CLAUDE.md`. Apply for all risk levels.
+
+1. Write a regression test that reproduces the original bug and confirm it fails
+   before any fix (RED).
+2. Verify that existing tests still pass.
+3. Produce a Test Report: test added, case covered.
+
+---
+
+## Step 5a — Implementation, low-risk (Implementer role)
 
 Adopt the **Implementer** role as defined in `CLAUDE.md`. Use the Task Card.
 Implementer creates a Git Worktree before touching any file; all edits happen inside it.
 
 1. Locate the defect using the reproduction steps.
 2. Apply the minimal fix — no unrelated changes.
-3. Run the test suite.
+3. Run the suite and make the RED regression test pass.
 4. Produce an Implementation Summary: root cause, fix applied, files changed.
 
 ---
 
-## Step 3b — Implementation, medium/high-risk (Implementer role)
+## Step 5b — Implementation, medium/high-risk (Implementer role)
 
 Adopt the **Implementer** role as defined in `CLAUDE.md`. Use the approved
 Technical Plan and the Task Card.
@@ -91,18 +156,7 @@ After implementation, run the full test suite.
 
 ---
 
-## Step 4 — Regression tests (Tester role)
-
-Adopt the **Tester** role as defined in `CLAUDE.md`. Apply for all risk levels.
-
-1. Write a regression test that reproduces the original bug (fails before the
-   fix, passes after).
-2. Verify that existing tests still pass.
-3. Produce a Test Report: test added, case covered.
-
----
-
-## Step 5 — Review (Reviewer role) — medium/high-risk only
+## Step 6 — Review (Reviewer role) — medium/high-risk only
 
 Adopt the **Reviewer** role as defined in `CLAUDE.md`. Use the diff and Task
 Card.

package/presets/claude/commands/cc/handoff.md

@@ -0,0 +1,44 @@
+---
+description: >-
+  [cc: alias] Compact the session into gitignored `.codeconductor/sessions/handoff.md` (redact secrets).
+---
+
+# Handoff Workflow
+
+Handoff request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `handoff` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command handoff "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command handoff "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile handoff --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command handoff --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Compact (docs)
+
+Invoke `docs`. Write **only** `.codeconductor/sessions/handoff.md` (gitignored).
+Do not write `.codeconductor/handoff.md` or any tracked path.
+
+Before writing, redact secrets, tokens, API keys, passwords, connection strings,
+`.env` contents, and log/stack-trace lines that embed those values. Summarize
+errors instead of pasting dumps. If unresolved credential material remains, stop
+and wait for a human (CCEP `stopOnHighRisk`).
+
+Include: goal, Task Card status (no secret fields), files touched, test
+pass/fail (not log dumps), open questions, the next `/cc:` command, and the
+recommended `context_scope` (`isolated` | `continuation` | `full`) for the next
+session — derived from the Task Card status above, not invented, with a
+one-sentence justification.
+
+Do not edit source or tests.
+
+---
+
+## Completion
+
+Report the handoff path. Another session should be able to continue from that file alone.