gsd-opencode 1.30.0 → 1.33.0

package/get-shit-done/workflows/discuss-phase-power.md

@@ -0,0 +1,291 @@
+<objective>
+Power user mode for discuss-phase. Generates ALL questions upfront into a JSON state file and an HTML companion UI, then waits for the user to answer at their own pace. When the user signals readiness, processes all answers in one pass and generates CONTEXT.md.
+
+**When to use:** Large phases with many gray areas, or when users prefer to answer questions offline / asynchronously rather than interactively in the chat session.
+</objective>
+
+<trigger>
+This workflow executes when `--power` flag is present in ARGUMENTS to `/gsd-discuss-phase`.
+
+The caller (discuss-phase.md) has already:
+- Validated the phase exists
+- Provided init context: `phase_dir`, `padded_phase`, `phase_number`, `phase_name`, `phase_slug`
+
+Begin at **Step 1** immediately.
+</trigger>
+
+<step name="analyze">
+Run the same gray area identification as standard discuss-phase mode.
+
+1. Load prior context (PROJECT.md, REQUIREMENTS.md, STATE.md, prior CONTEXT.md files)
+2. Scout codebase for reusable assets and patterns relevant to this phase
+3. read the phase goal from ROADMAP.md
+4. Identify ALL gray areas — specific implementation decisions the user should weigh in on
+5. For each gray area, generate 2–4 concrete options with tradeoff descriptions
+
+Group questions by topic into sections (e.g., "Visual Style", "Data Model", "Interactions", "Error Handling"). Each section should have 2–6 questions.
+
+Do NOT ask the user anything at this stage. Capture everything internally, then proceed to generate.
+</step>
+
+<step name="generate_json">
+write all questions to:
+
+```
+{phase_dir}/{padded_phase}-QUESTIONS.json
+```
+
+**JSON structure:**
+
+```json
+{
+  "phase": "{padded_phase}-{phase_slug}",
+  "generated_at": "ISO-8601 timestamp",
+  "stats": {
+    "total": 0,
+    "answered": 0,
+    "chat_more": 0,
+    "remaining": 0
+  },
+  "sections": [
+    {
+      "id": "section-slug",
+      "title": "Section Title",
+      "questions": [
+        {
+          "id": "Q-01",
+          "title": "Short question title",
+          "context": "Codebase info, prior decisions, or constraints relevant to this question",
+          "options": [
+            {
+              "id": "a",
+              "label": "Option label",
+              "description": "Tradeoff or elaboration for this option"
+            },
+            {
+              "id": "b",
+              "label": "Another option",
+              "description": "Tradeoff or elaboration"
+            },
+            {
+              "id": "c",
+              "label": "Custom",
+              "description": ""
+            }
+          ],
+          "answer": null,
+          "chat_more": "",
+          "status": "unanswered"
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Field rules:**
+- `stats.total`: count of all questions across all sections
+- `stats.answered`: count where `answer` is not null and not empty string
+- `stats.chat_more`: count where `chat_more` has content
+- `stats.remaining`: `total - answered`
+- `question.id`: sequential across all sections — Q-01, Q-02, Q-03, ...
+- `question.context`: concrete codebase or prior-decision annotation (not generic)
+- `question.answer`: null until user sets it; once answered, the selected option id or free-text
+- `question.status`: "unanswered" | "answered" | "chat-more" (has chat_more but no answer yet)
+</step>
+
+<step name="generate_html">
+write a self-contained HTML companion file to:
+
+```
+{phase_dir}/{padded_phase}-QUESTIONS.html
+```
+
+The file must be a single self-contained HTML file with inline CSS and JavaScript. No external dependencies.
+
+**Layout:**
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Phase {N}: {phase_name} — Discussion Questions      │
+│  ┌──────────────────────────────────────────────┐   │
+│  │  12 total  |  3 answered  |  9 remaining     │   │
+│  └──────────────────────────────────────────────┘   │
+├─────────────────────────────────────────────────────┤
+│  ▼ Visual Style (3 questions)                        │
+│   ┌──────────┐ ┌──────────┐ ┌──────────┐            │
+│   │ Q-01     │ │ Q-02     │ │ Q-03     │            │
+│   │ Layout   │ │ Density  │ │ Colors   │            │
+│   │ ...      │ │ ...      │ │ ...      │            │
+│   └──────────┘ └──────────┘ └──────────┘            │
+│  ▼ Data Model (2 questions)                          │
+│   ...                                                │
+└─────────────────────────────────────────────────────┘
+```
+
+**Stats bar:**
+- Total questions, answered count, remaining count
+- A simple CSS progress bar (green fill = answered / total)
+
+**Section headers:**
+- Collapsible via click — show/hide questions in the section
+- Show answered count for the section (e.g., "2/4 answered")
+
+**question cards (3-column grid):**
+Each card contains:
+- question ID badge (e.g., "Q-01") and title
+- Context annotation (gray italic text)
+- Option list: radio buttons with bold label + description text
+- Chat more textarea (orange border when content present)
+- Card highlighted green when answered
+
+**JavaScript behavior:**
+- On radio button select: mark question as answered in page state; update stats bar
+- On textarea input: update chat_more content in page state; show orange border if content present
+- "Save answers" button at top and bottom: serializes page state back to the JSON file path
+
+**Save mechanism:**
+The Save button writes the updated JSON back using the File System Access API if available, otherwise generates a downloadable JSON file the user can save over the original. Include clear instructions in the UI:
+
+```
+After answering, click "Save answers" — or download the JSON and replace the original file.
+Then return to OpenCode and say "refresh" to process your answers.
+```
+
+**Answered question styling:**
+- Card border: `2px solid #22c55e` (green)
+- Card background: `#f0fdf4` (light green tint)
+
+**Unanswered question styling:**
+- Card border: `1px solid #e2e8f0` (gray)
+- Card background: `white`
+
+**Chat more textarea:**
+- Placeholder: "Add context, nuance, or clarification for this question..."
+- Normal border: `1px solid #e2e8f0`
+- Active (has content) border: `2px solid #f97316` (orange)
+</step>
+
+<step name="notify_user">
+After writing both files, print this message to the user:
+
+```
+Questions ready for Phase {N}: {phase_name}
+
+  HTML (open in browser/IDE):   {phase_dir}/{padded_phase}-QUESTIONS.html
+  JSON (state file):            {phase_dir}/{padded_phase}-QUESTIONS.json
+
+  {total} questions across {section_count} topics.
+
+Open the HTML file, answer the questions at your own pace, then save.
+
+When ready, tell me:
+  "refresh"   — process your answers and update the file
+  "finalize"  — generate CONTEXT.md from all answered questions
+  "explain Q-05"   — elaborate on a specific question
+  "exit power mode" — return to standard one-by-one discussion (answers carry over)
+```
+</step>
+
+<step name="wait_loop">
+Enter wait mode. OpenCode listens for user commands and handles each:
+
+---
+
+**"refresh"** (or "process answers", "update", "re-read"):
+
+1. read `{phase_dir}/{padded_phase}-QUESTIONS.json`
+2. Recalculate stats: count answered, chat_more, remaining
+3. write updated stats back to the JSON
+4. Re-generate the HTML file with the updated state (answered cards highlighted green, progress bar updated)
+5. Report to user:
+
+```
+Refreshed. Updated state:
+  Answered:  {answered} / {total}
+  Remaining: {remaining}
+  Chat-more: {chat_more}
+
+  {phase_dir}/{padded_phase}-QUESTIONS.html updated.
+
+Answer more questions, then say "refresh" again, or say "finalize" when done.
+```
+
+---
+
+**"finalize"** (or "done", "generate context", "write context"):
+
+Proceed to the **finalize** step.
+
+---
+
+**"explain Q-{N}"** (or "more info on Q-{N}", "elaborate Q-{N}"):
+
+1. Find the question by ID in the JSON
+2. Provide a detailed explanation: why this decision matters, how it affects the downstream plan, what additional context from the codebase is relevant
+3. Return to wait mode
+
+---
+
+**"exit power mode"** (or "switch to interactive"):
+
+1. read all currently answered questions from JSON
+2. Load answers into the internal accumulator as if they were answered interactively
+3. Continue with standard `discuss_areas` step from discuss-phase.md for any unanswered questions
+4. Generate CONTEXT.md as normal
+
+---
+
+**Any other message:**
+Respond helpfully, then remind the user of available commands:
+```
+(Power mode active — say "refresh", "finalize", "explain Q-N", or "exit power mode")
+```
+</step>
+
+<step name="finalize">
+Process all answered questions from the JSON file and generate CONTEXT.md.
+
+1. read `{phase_dir}/{padded_phase}-QUESTIONS.json`
+2. Filter to questions where `answer` is not null/empty
+3. Group decisions by section
+4. For each answered question, format as a decision entry:
+   - Decision: the selected option label (or custom text if free-form answer)
+   - Rationale: the option description, plus `chat_more` content if present
+   - Status: "Decided" if fully answered, "Needs clarification" if only chat_more with no option selected
+
+5. write CONTEXT.md using the standard context template format:
+   - `<decisions>` section with all answered questions grouped by section
+   - `<deferred_ideas>` section for unanswered questions (carry forward for future discussion)
+   - `<specifics>` section for any chat_more content that adds nuance
+   - `<code_context>` section with reusable assets found during analysis
+   - `<canonical_refs>` section (MANDATORY — paths to relevant specs/docs)
+
+6. If fewer than 50% of questions were answered, warn the user:
+```
+Warning: Only {answered}/{total} questions answered ({pct}%).
+CONTEXT.md generated with available decisions. Unanswered questions listed as deferred.
+Consider running /gsd-discuss-phase {N} again to refine before planning.
+```
+
+7. Print completion message:
+```
+CONTEXT.md written: {phase_dir}/{padded_phase}-CONTEXT.md
+
+  Decisions captured: {answered}
+  Deferred:          {remaining}
+
+Next step: /gsd-plan-phase {N}
+```
+</step>
+
+<success_criteria>
+- Questions generated into well-structured JSON covering all identified gray areas
+- HTML companion file is self-contained and usable without a server
+- Stats bar accurately reflects answered/remaining counts after each refresh
+- Answered questions highlighted green in HTML
+- CONTEXT.md generated in the same format as standard discuss-phase output
+- Unanswered questions preserved as deferred items (not silently dropped)
+- `canonical_refs` section always present in CONTEXT.md (MANDATORY)
+- User knows how to refresh, finalize, explain, or exit power mode
+</success_criteria>

package/get-shit-done/workflows/discuss-phase.md

@@ -4,6 +4,12 @@ Extract implementation decisions that downstream agents need. Analyze the phase
 You are a thinking partner, not an interviewer. The user is the visionary — you are the builder. Your job is to capture decisions that will guide research and planning, not to figure out implementation yourself.
 </objective>
 
+<required_reading>
+@$HOME/.config/opencode/get-shit-done/references/domain-probes.md
+@$HOME/.config/opencode/get-shit-done/references/gate-prompts.md
+@$HOME/.config/opencode/get-shit-done/references/universal-anti-patterns.md
+</required_reading>
+
 <downstream_awareness>
 **CONTEXT.md feeds into:**
 
@@ -137,7 +143,9 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_ADVISOR=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" agent-skills gsd-advisor 2>/dev/null)
 ```
 
-Parse JSON for: `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_research`, `has_context`, `has_plans`, `has_verification`, `plan_count`, `roadmap_exists`, `planning_exists`.
+Parse JSON for: `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_research`, `has_context`, `has_plans`, `has_verification`, `plan_count`, `roadmap_exists`, `planning_exists`, `response_language`.
+
+**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. This includes question labels, option text, gray area descriptions, and discussion summaries. Technical terms, code, and file paths remain in English. Subagent prompts stay in English — only user-facing output is translated.
 
 **If `phase_found` is false:**
 ```
@@ -149,12 +157,46 @@ Exit workflow.
 
 **If `phase_found` is true:** Continue to check_existing.
 
+**Power mode** — If `--power` is present in ARGUMENTS:
+- Skip interactive questioning entirely
+- read and execute @$HOME/.config/opencode/get-shit-done/workflows/discuss-phase-power.md end-to-end
+- Do not continue with the steps below
+
 **Auto mode** — If `--auto` is present in ARGUMENTS:
 - In `check_existing`: auto-select "Skip" (if context exists) or continue without prompting (if no context/plans)
 - In `present_gray_areas`: auto-select ALL gray areas without asking the user
 - In `discuss_areas`: for each discussion question, choose the recommended option (first option, or the one marked "recommended") without using question
 - Log each auto-selected choice inline so the user can review decisions in the context file
 - After discussion completes, auto-advance to plan-phase (existing behavior)
+
+**Chain mode** — If `--chain` is present in ARGUMENTS:
+- Discussion is fully interactive (questions, gray area selection — same as default mode)
+- After discussion completes, auto-advance to plan-phase → execute-phase (same as `--auto`)
+- This is the middle ground: user controls the discuss decisions, then plan+execute run autonomously
+</step>
+
+<step name="check_blocking_antipatterns" priority="first">
+**MANDATORY — Check for blocking anti-patterns before any other work.**
+
+Look for a `.continue-here.md` in the current phase directory:
+
+```bash
+ls ${phase_dir}/.continue-here.md 2>/dev/null || true
+```
+
+If `.continue-here.md` exists, parse its "Critical Anti-Patterns" table for rows with `severity` = `blocking`.
+
+**If one or more `blocking` anti-patterns are found:**
+
+This step cannot be skipped. Before proceeding to `check_existing` or any other step, the agent must demonstrate understanding of each blocking anti-pattern by answering all three questions for each one:
+
+1. **What is this anti-pattern?** — Describe it in your own words, not by quoting the handoff.
+2. **How did it manifest?** — Explain the specific failure that caused it to be recorded.
+3. **What structural mechanism (not acknowledgment) prevents it?** — Name the concrete step, checklist item, or enforcement mechanism that stops recurrence.
+
+write these answers inline before continuing. If a blocking anti-pattern cannot be answered from the context in `.continue-here.md`, stop and ask the user for clarification.
+
+**If no `.continue-here.md` exists, or no `blocking` rows are found:** Proceed directly to `check_existing`.
 </step>
 
 <step name="check_existing">
@@ -182,6 +224,26 @@ If "Skip": Exit workflow
 
 **If doesn't exist:**
 
+**Check for interrupted discussion checkpoint:**
+
+```bash
+ls ${phase_dir}/*-DISCUSS-CHECKPOINT.json 2>/dev/null || true
+```
+
+If a checkpoint file exists (previous session was interrupted before CONTEXT.md was written):
+
+**If `--auto`:** Auto-select "Resume" — load checkpoint and continue from last completed area.
+
+**Otherwise:** Use question:
+- header: "Resume"
+- question: "Found interrupted discussion checkpoint ({N} areas completed out of {M}). Resume from where you left off?"
+- options:
+  - "Resume" — Load checkpoint, skip completed areas, continue discussion
+  - "Start fresh" — Delete checkpoint, start discussion from scratch
+
+If "Resume": Parse the checkpoint JSON. Load `decisions` into the internal accumulator. Set `areas_completed` to skip those areas. Continue to `present_gray_areas` with only the remaining areas.
+If "Start fresh": Delete the checkpoint file. Continue as if no checkpoint existed.
+
 Check `has_plans` and `plan_count` from init. **If `has_plans` is true:**
 
 **If `--auto`:** Auto-select "Continue and replan after". Log: `[auto] Plans exist — continuing with context capture, will replan after.`
@@ -640,6 +702,16 @@ Each answer (or answer set, in batch mode) should reveal the next question or ne
 ```
 After all areas are auto-resolved, skip the "Explore more gray areas" prompt and proceed directly to write_context.
 
+**CRITICAL — Auto-mode pass cap:**
+In `--auto` mode, the discuss step MUST complete in a **single pass**. After writing CONTEXT.md once, you are DONE — proceed immediately to write_context and then auto_advance. Do NOT re-read your own CONTEXT.md to find "gaps", "undefined types", or "missing decisions" and run additional passes. This creates a self-feeding loop where each pass generates references that the next pass treats as gaps, consuming unbounded time and resources.
+
+Check the pass cap from config:
+```bash
+MAX_PASSES=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" config-get workflow.max_discuss_passes 2>/dev/null || echo "3")
+```
+
+If you have already written and committed CONTEXT.md, the discuss step is complete. Move on.
+
 **Interactive mode (no `--auto`):**
 
 **For each area:**
@@ -719,6 +791,44 @@ Back to [current area]: [return to current question]"
 
 Track deferred ideas internally.
 
+**Incremental checkpoint — save after each area completes:**
+
+After each area is resolved (user says "Next area" or area auto-resolves in `--auto` mode), immediately write a checkpoint file with all decisions captured so far. This prevents data loss if the session is interrupted mid-discussion.
+
+**Checkpoint file:** `${phase_dir}/${padded_phase}-DISCUSS-CHECKPOINT.json`
+
+write after each area:
+```json
+{
+  "phase": "{PHASE_NUM}",
+  "phase_name": "{phase_name}",
+  "timestamp": "{ISO timestamp}",
+  "areas_completed": ["Area 1", "Area 2"],
+  "areas_remaining": ["Area 3", "Area 4"],
+  "decisions": {
+    "Area 1": [
+      {"question": "...", "answer": "...", "options_presented": ["..."]},
+      {"question": "...", "answer": "...", "options_presented": ["..."]}
+    ],
+    "Area 2": [
+      {"question": "...", "answer": "...", "options_presented": ["..."]}
+    ]
+  },
+  "deferred_ideas": ["..."],
+  "canonical_refs": ["..."]
+}
+```
+
+This is a structured checkpoint, not the final CONTEXT.md — the `write_context` step still produces the canonical output. But if the session dies, the next `/gsd-discuss-phase` invocation can detect this checkpoint and offer to resume from it instead of starting from scratch.
+
+**On session resume:** In the `check_existing` step, also check for `*-DISCUSS-CHECKPOINT.json`. If found and no CONTEXT.md exists:
+- Display: "Found interrupted discussion checkpoint ({N} areas completed). Resume from checkpoint?"
+- Options: "Resume" / "Start fresh"
+- On "Resume": Load the checkpoint, skip completed areas, continue from where it left off
+- On "Start fresh": Delete the checkpoint, proceed as normal
+
+**After write_context completes successfully:** Delete the checkpoint file — the canonical CONTEXT.md now has all decisions.
+
 **Track discussion log data internally:**
 For each question asked, accumulate:
 - Area name
@@ -873,13 +983,14 @@ Created: .planning/phases/${PADDED_PHASE}-${SLUG}/${PADDED_PHASE}-CONTEXT.md
 
 **Phase ${PHASE}: [Name]** — [Goal from ROADMAP.md]
 
-`/gsd-plan-phase ${PHASE} ${GSD_WS}`
+`/new` then:
 
-*`/new` first → fresh context window*
+`/gsd-plan-phase ${PHASE} ${GSD_WS}`
 
 ---
 
 **Also available:**
+- `/gsd-discuss-phase ${PHASE} --chain ${GSD_WS}` — re-run with auto plan+execute after
 - `/gsd-plan-phase ${PHASE} --skip-research ${GSD_WS}` — plan without research
 - `/gsd-ui-phase ${PHASE} ${GSD_WS}` — generate UI design contract before planning (if phase has frontend work)
 - Review/edit CONTEXT.md before continuing
@@ -933,6 +1044,12 @@ Created: .planning/phases/${PADDED_PHASE}-${SLUG}/${PADDED_PHASE}-CONTEXT.md
 
 write file.
 
+**Clean up checkpoint file** — CONTEXT.md is now the canonical record:
+
+```bash
+rm -f "${phase_dir}/${padded_phase}-DISCUSS-CHECKPOINT.json"
+```
+
 Commit phase context and discussion log:
 
 ```bash
@@ -961,10 +1078,10 @@ node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" commit "docs(state
 <step name="auto_advance">
 Check for auto-advance trigger:
 
-1. Parse `--auto` flag from $ARGUMENTS
-2. **Sync chain flag with intent** — if user invoked manually (no `--auto`), clear the ephemeral chain flag from any previous interrupted `--auto` chain. This does NOT touch `workflow.auto_advance` (the user's persistent settings preference):
+1. Parse `--auto` and `--chain` flags from $ARGUMENTS
+2. **Sync chain flag with intent** — if user invoked manually (no `--auto` and no `--chain`), clear the ephemeral chain flag from any previous interrupted `--auto` chain. This does NOT touch `workflow.auto_advance` (the user's persistent settings preference):
    ```bash
-   if [[ ! "$ARGUMENTS" =~ --auto ]]; then
+   if [[ ! "$ARGUMENTS" =~ --auto ]] && [[ ! "$ARGUMENTS" =~ --chain ]]; then
      node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" config-set workflow._auto_chain_active false 2>/dev/null
    fi
    ```
@@ -974,12 +1091,12 @@ Check for auto-advance trigger:
    AUTO_CFG=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" config-get workflow.auto_advance 2>/dev/null || echo "false")
    ```
 
-**If `--auto` flag present AND `AUTO_CHAIN` is not true:** Persist chain flag to config (handles direct `--auto` usage without new-project):
+**If `--auto` or `--chain` flag present AND `AUTO_CHAIN` is not true:** Persist chain flag to config (handles direct usage without new-project):
 ```bash
 node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" config-set workflow._auto_chain_active true
 ```
 
-**If `--auto` flag present OR `AUTO_CHAIN` is true OR `AUTO_CFG` is true:**
+**If `--auto` flag present OR `--chain` flag present OR `AUTO_CHAIN` is true OR `AUTO_CFG` is true:**
 
 Display banner:
 ```
@@ -1006,8 +1123,9 @@ This keeps the auto-advance chain flat — discuss, plan, and execute all run at
 
   Auto-advance pipeline finished: discuss → plan → execute
 
-  Next: /gsd-discuss-phase ${NEXT_PHASE} --auto ${GSD_WS}
-  */new first → fresh context window*
+  /new then:
+
+  Next: /gsd-discuss-phase ${NEXT_PHASE} ${WAS_CHAIN ? "--chain" : "--auto"} ${GSD_WS}
   ```
 - **PLANNING COMPLETE** → Planning done, execution didn't complete:
   ```
@@ -1025,12 +1143,27 @@ This keeps the auto-advance chain flat — discuss, plan, and execute all run at
   Continue: /gsd-plan-phase ${PHASE} --gaps ${GSD_WS}
   ```
 
-**If neither `--auto` nor config enabled:**
+**If none of `--auto`, `--chain`, nor config enabled:**
 Route to `confirm_creation` step (existing behavior — show manual next steps).
 </step>
 
 </process>
 
+<power_user_mode>
+When `--power` flag is present in ARGUMENTS, skip interactive questioning and execute the power user workflow.
+
+The power user mode generates ALL questions upfront into machine-readable and human-friendly files, then waits for the user to answer at their own pace before processing all answers in a single pass.
+
+**Full step-by-step instructions:** @$HOME/.config/opencode/get-shit-done/workflows/discuss-phase-power.md
+
+**Summary of flow:**
+1. Run the same phase analysis (gray area identification) as standard mode
+2. write all questions to `{phase_dir}/{padded_phase}-QUESTIONS.json` and `{phase_dir}/{padded_phase}-QUESTIONS.html`
+3. Notify user with file paths and wait for a "refresh" or "finalize" command
+4. On "refresh": read the JSON, process answered questions, update stats and HTML
+5. On "finalize": read all answers from JSON, generate CONTEXT.md in the standard format
+</power_user_mode>
+
 <success_criteria>
 - Phase validated against roadmap
 - Prior context loaded (PROJECT.md, REQUIREMENTS.md, STATE.md, prior CONTEXT.md files)
@@ -1046,4 +1179,9 @@ Route to `confirm_creation` step (existing behavior — show manual next steps).
 - Deferred ideas preserved for future phases
 - STATE.md updated with session info
 - User knows next steps
+- Checkpoint file written after each area completes (incremental save)
+- Interrupted sessions can be resumed from checkpoint (no re-answering completed areas)
+- Checkpoint file cleaned up after successful CONTEXT.md write
+- `--chain` triggers interactive discuss followed by auto plan+execute (no auto-answering)
+- `--chain` and `--auto` both persist chain flag and auto-advance to plan-phase
 </success_criteria>