From fb85057f966265adef3aac6c51d66672969e0524 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 09:10:58 -0700
Subject: [PATCH 1/9] feat: strengthen stage handoffs and add /kw:lfg
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Align Compound Knowledge loop progression with Compound Engineering:
explicit stage banners, mandatory end-of-stage handoffs that load the
next skill, and a hands-off /kw:lfg runner (plan → review → work → compound).
---
 .claude-plugin/marketplace.json                       | 6 +++---
 plugins/compound-knowledge/.claude-plugin/plugin.json | 7 ++++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 1909c3e..368373a 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -6,20 +6,20 @@
   },
   "metadata": {
     "description": "Workflows for knowledge work that compounds over time",
-    "version": "1.0.0"
+    "version": "1.1.0"
   },
   "plugins": [
     {
       "name": "compound-knowledge",
       "description": "Knowledge compounds. Brainstorm, plan, review, execute, and save what you learn — so the next cycle starts smarter.",
-      "version": "1.0.0",
+      "version": "1.1.0",
       "author": {
         "name": "Austin Tedesco",
         "url": "https://every.to",
         "email": "austin@every.to"
       },
       "homepage": "https://every.to/p/how-to-build-a-command-center-that-keeps-you-sane",
-      "tags": ["knowledge-work", "planning", "review", "compounding", "brainstorm"],
+      "tags": ["knowledge-work", "planning", "review", "compounding", "brainstorm", "lfg"],
       "source": "./plugins/compound-knowledge"
     }
   ]
diff --git a/plugins/compound-knowledge/.claude-plugin/plugin.json b/plugins/compound-knowledge/.claude-plugin/plugin.json
index ce80a1a..1aa4dd0 100644
--- a/plugins/compound-knowledge/.claude-plugin/plugin.json
+++ b/plugins/compound-knowledge/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "compound-knowledge",
-  "version": "1.0.0",
-  "description": "Knowledge compounds. Brainstorm, plan, review, execute, and save what you learn — so the next cycle starts smarter. 6 skills, 5 agents.",
+  "version": "1.1.0",
+  "description": "Knowledge compounds. Brainstorm, plan, review, execute, and save what you learn — so the next cycle starts smarter. 7 skills, 5 agents.",
   "author": {
     "name": "Austin Tedesco",
     "email": "austin@every.to",
@@ -18,6 +18,7 @@
     "brainstorm",
     "strategy",
     "campaign",
-    "brief"
+    "brief",
+    "lfg"
   ]
 }

From 20230a06a6d004ec3e35ed2c06bffc9bc0372b07 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 09:12:53 -0700
Subject: [PATCH 2/9] docs: document stage handoffs and /kw:lfg

---
 README.md                                     |  16 ++-
 plugins/compound-knowledge/AGENTS.md          |  13 +-
 plugins/compound-knowledge/CHANGELOG.md       |  18 ++-
 plugins/compound-knowledge/README.md          |  16 ++-
 .../compound-knowledge/skills/kw-lfg/SKILL.md | 125 ++++++++++++++++++
 5 files changed, 182 insertions(+), 6 deletions(-)
 create mode 100644 plugins/compound-knowledge/skills/kw-lfg/SKILL.md

diff --git a/README.md b/README.md
index e1b87a0..8471823 100644
--- a/README.md
+++ b/README.md
@@ -13,10 +13,14 @@ Read the story: [How to Build a Command Center That Keeps You Sane](https://ever
 /kw:review       -->  Strategic alignment + data accuracy check
 /kw:work         -->  Execute the plan, produce deliverables
 /kw:compound     -->  Save learnings for next time
+
+/kw:lfg          -->  Hands-off: plan → review → work → compound (no stage check-ins)
 ```
 
 Each cycle makes the next one faster. `/kw:plan` searches `docs/knowledge/` for past learnings saved by `/kw:compound`. Knowledge compounds.
 
+After `/kw:brainstorm`, you get an explicit handoff — create a plan, or ship the rest of the loop with `/kw:lfg` — so you don't lose track of which stage you're in.
+
 ## Install
 
 Inside a [Claude Code](https://claude.ai/claude-code) session:
@@ -40,6 +44,12 @@ When you're ready to commit to a direction:
 /kw:plan
 ```
 
+Or run the rest of the loop hands-off (plan → review → work → compound):
+
+```
+/kw:lfg
+```
+
 After any meaningful session, save what you learned:
 
 ```
@@ -79,6 +89,10 @@ Execute a plan. Break it into tasks, group by dependency, run independent tasks
 
 Extract 1-3 learnings from a session. Checks for stale knowledge that the new learning contradicts. Saves to `docs/knowledge/` with searchable YAML frontmatter.
 
+### LFG
+
+Hands-off runner for the rest of the loop — knowledge-work counterpart to Compound Engineering's `/lfg`. Runs plan → review → work → compound without asking which stage is next.
+
 ## How It Works
 
 1. You brainstorm and plan something
@@ -111,7 +125,7 @@ delay revenue recognition. Net positive after 60 days.
 
 | Type | Count | Description |
 |------|-------|-------------|
-| Skills | 6 | brainstorm, plan, confidence, review, work, compound |
+| Skills | 7 | brainstorm, plan, confidence, review, work, compound, lfg |
 | Review Agents | 2 | strategic-alignment, data-accuracy |
 | Research Agents | 3 | past-work-researcher, knowledge-base-researcher, stale-knowledge-checker |
 
diff --git a/plugins/compound-knowledge/AGENTS.md b/plugins/compound-knowledge/AGENTS.md
index f2d2d5d..a8f7512 100644
--- a/plugins/compound-knowledge/AGENTS.md
+++ b/plugins/compound-knowledge/AGENTS.md
@@ -6,13 +6,14 @@
 compound-knowledge/
 ├── AGENTS.md                        # Dev conventions (this file)
 ├── CLAUDE.md                        # Shim → @AGENTS.md
-├── skills/                          # 6 workflow skills
+├── skills/                          # 7 workflow skills
 │   ├── kw-brainstorm/SKILL.md
 │   ├── kw-plan/SKILL.md
 │   ├── kw-confidence/SKILL.md
 │   ├── kw-review/SKILL.md
 │   ├── kw-work/SKILL.md
-│   └── kw-compound/SKILL.md
+│   ├── kw-compound/SKILL.md
+│   └── kw-lfg/SKILL.md              # Hands-off loop (plan → review → work → compound)
 ├── agents/                          # 5 task agents
 │   ├── review/
 │   │   ├── strategic-alignment-reviewer.md
@@ -38,6 +39,10 @@ compound-knowledge/
 
 * Skills that accept arguments include an XML capture tag after frontmatter (e.g., `<brain_dump> #$ARGUMENTS </brain_dump>`)
 
+* End-of-stage handoffs must (1) name the completed stage, (2) present next options, and (3) immediately load the chosen next skill when applicable — never silently skip the handoff
+
+* `/kw:lfg` is the only skill that chains stages without check-ins; other skills stay single-stage unless the user picks a handoff option
+
 * Review agents live in `agents/review/`
 
 * Research agents live in `agents/research/`
@@ -58,4 +63,6 @@ Every change must update:
 
 * **Local first.** `docs/knowledge/` is the primary knowledge store. External integrations (Notion, etc.) are optional and project-specific.
 
-* **Progressive disclosure.** Start with the 6 workflows. Add skills and agents as patterns emerge.
+* **Progressive disclosure.** Start with the core workflows. Add skills and agents as patterns emerge. `/kw:lfg` is the autonomous path for users who already trust the loop.
+
+* **Stage clarity.** Users should always know whether they are in brainstorm, plan, review, work, or compound.
diff --git a/plugins/compound-knowledge/CHANGELOG.md b/plugins/compound-knowledge/CHANGELOG.md
index 6907676..d56d774 100644
--- a/plugins/compound-knowledge/CHANGELOG.md
+++ b/plugins/compound-knowledge/CHANGELOG.md
@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.1.0] - 2026-08-31
+
+### Added
+
+* `/kw:lfg` — Hands-off loop runner (plan → review → work → compound), the knowledge-work counterpart to Compound Engineering's `/lfg`
+* Stage orientation banners on all workflow skills (`**Stage: …**`) so mid-conversation it stays clear which phase you're in
+* Mandatory end-of-stage handoff menus that recommend the next skill and, when chosen, immediately load it (instead of only suggesting the user type the command)
+* Brainstorm / plan handoff option: **Ship the loop with `/kw:lfg`**
+
+### Changed
+
+* `/kw:brainstorm` Step 7 reframed as an explicit "Brainstorm complete" handoff (never skip), aligned with CE's post-brainstorm progression
+* `/kw:plan`, `/kw:review`, `/kw:work`, and `/kw:compound` handoffs strengthened with stage-complete preambles and immediate skill load on selection
+* `/kw:confidence` re-anchors to the interrupted parent stage after the check
+* README / component counts updated for 7 skills
+
 ## [1.0.0] - 2026-03-22
 
 ### Added
@@ -52,4 +68,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 * Data accuracy reviewer agent
 
-* README with install and usage instructions
\ No newline at end of file
+* README with install and usage instructions
diff --git a/plugins/compound-knowledge/README.md b/plugins/compound-knowledge/README.md
index 1cb7a29..c3178a9 100644
--- a/plugins/compound-knowledge/README.md
+++ b/plugins/compound-knowledge/README.md
@@ -11,10 +11,14 @@ Workflows for knowledge work that compounds over time. The knowledge work equiva
 /kw:review       -->  Strategic alignment + data accuracy check
 /kw:work         -->  Execute the plan, produce deliverables
 /kw:compound     -->  Save learnings for next time
+
+/kw:lfg          -->  Hands-off: plan → review → work → compound (no stage check-ins)
 ```
 
 Each cycle makes the next one faster. `/kw:plan` searches `docs/knowledge/` for past learnings saved by `/kw:compound`. Knowledge compounds.
 
+After `/kw:brainstorm`, the skill ends with an explicit handoff (create plan, or ship the rest with `/kw:lfg`) so you always know which stage you're in.
+
 ## Install
 
 Inside a [Claude Code](https://claude.ai/claude-code) session:
@@ -38,6 +42,12 @@ When you're ready to commit to a direction:
 /kw:plan
 ```
 
+Or hand off the rest of the loop with no check-ins between stages:
+
+```
+/kw:lfg
+```
+
 After any meaningful session, save what you learned:
 
 ```
@@ -77,6 +87,10 @@ Execute a plan. Break it into tasks, group by dependency, run independent tasks
 
 Extract 1-3 learnings from a session. Checks for stale knowledge that the new learning contradicts. Saves to `docs/knowledge/` with searchable YAML frontmatter.
 
+### LFG
+
+Hands-off runner for the rest of the loop — the knowledge-work counterpart to Compound Engineering's `/lfg`. Invokes plan → review → work → compound without asking which stage is next. Enter from a brainstorm origin doc, a topic, or `plan:<path>` to skip re-planning. Stops on unresolved P1 review findings. Ends at deliverables + compounded knowledge (no PR/CI shipping).
+
 ## How It Works
 
 1. You brainstorm and plan something
@@ -109,7 +123,7 @@ delay revenue recognition. Net positive after 60 days.
 
 | Type | Count | Description |
 |------|-------|-------------|
-| Skills | 6 | brainstorm, plan, confidence, review, work, compound |
+| Skills | 7 | brainstorm, plan, confidence, review, work, compound, lfg |
 | Review Agents | 2 | strategic-alignment, data-accuracy |
 | Research Agents | 3 | past-work-researcher, knowledge-base-researcher, stale-knowledge-checker |
 
diff --git a/plugins/compound-knowledge/skills/kw-lfg/SKILL.md b/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
new file mode 100644
index 0000000..75e51fa
--- /dev/null
+++ b/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
@@ -0,0 +1,125 @@
+---
+name: kw:lfg
+description: "Run the full Compound Knowledge loop end-to-end, hands-off with no check-ins between stages. Use only when the user explicitly asks to ship the knowledge-work loop autonomously (plan → review → work → compound), or invokes /kw:lfg directly. Not for in-the-loop work where the user reviews each stage — use /kw:plan, /kw:review, /kw:work, or /kw:compound instead."
+argument-hint: "[topic, brainstorm path, or plan:<path> to skip planning]"
+---
+
+<lfg_request> #$ARGUMENTS </lfg_request>
+
+# LFG (Knowledge Work)
+
+Run the Compound Knowledge loop autonomously: **plan → review → work → compound**. No stage-handoff menus. Narrate progress; do not stop to ask which stage is next.
+
+This is the knowledge-work counterpart to Compound Engineering's `/lfg`. CE ships code to an open PR; CK ships knowledge deliverables and compounds learnings into `docs/knowledge/`.
+
+CRITICAL: Execute every step below **in order**. Do not jump ahead to `/kw:work` before a plan exists (unless invoked with `plan:<path>`). Do not ask "what next?" between stages.
+
+Resolve every skill named below against the host's available-skills list and invoke that exact entry (hosts may namespace it, e.g. `compound-knowledge:kw-plan`).
+
+## When to Use
+
+* User says "just run the loop", "lfg", "ship it", or picks **Ship the loop with `/kw:lfg`** from a brainstorm/plan handoff
+* Direction is clear enough that mid-loop steering is optional
+* **Not** for exploratory brainstorming — finish `/kw:brainstorm` interactively first, then LFG
+
+## Inputs
+
+Parse `$ARGUMENTS`:
+
+| Form | Meaning |
+|------|---------|
+| `plan:plans/...md` or `plan:<path>` | Skip Step 1. Use this plan; start at review. |
+| Path to `plans/brainstorm-*.md` | Origin doc for planning. |
+| Free-text topic | Plan from the topic (and any prior conversation context). |
+| Empty | Use the most recent brainstorm in `plans/`, else the active conversation topic. If neither exists, STOP and tell the user what to pass. |
+
+## Stage narration
+
+Before each step, one line:
+
+```
+**LFG → Stage: [Plan|Review|Work|Compound]** — [what this step should produce]
+```
+
+After each step, one line naming what it produced (plan path, P1 count, deliverable count, knowledge files).
+
+## Pipeline contract
+
+When invoking child skills, run them in **Pipeline Mode**:
+
+* Pass context equivalent to `disable-model-invocation` / pipeline so they skip AskUserQuestion
+* Use sensible defaults; write files without waiting
+* Do **not** present their interactive handoff menus — LFG owns progression
+* Child skills still follow their Important Rules (cite sources, write execution logs, etc.)
+
+---
+
+## Step 1: Plan
+
+**Skip** if invoked with `plan:<path>` and that file exists.
+
+1. Invoke `kw:plan` on the brainstorm path or topic.
+2. GATE: STOP if no plan file was written. Report why and halt.
+3. **Record `plan_path`** for later steps.
+
+## Step 2: Review
+
+1. Invoke `kw:review` on `plan_path`.
+2. If **P1** findings exist:
+   - Attempt a single auto-fix pass on the plan (and any attached brief) addressing each P1
+   - Re-run `kw:review` once
+   - If P1s remain: GATE STOP. Report remaining P1s and `plan_path`. Do not execute a plan with unresolved critical findings unless the user later overrides interactively.
+3. P2/P3 findings: note them in narration; continue (apply obvious safe P2 fixes when cheap; otherwise leave for compound/residuals).
+
+## Step 3: Work
+
+1. Invoke `kw:work` on `plan_path`.
+2. In pipeline mode: skip per-batch approval prompts; still write the **Execution Log** into the plan file after each batch.
+3. GATE: STOP if zero deliverables were produced and work is blocked on missing access/info the agent cannot resolve. Report blockers and `plan_path`.
+4. **Record deliverable paths** for the close-out.
+
+## Step 4: Compound
+
+1. Invoke `kw:compound` against this session (plan + execution log + deliverables).
+2. In pipeline mode: auto-approve **1–3** high-signal learnings; skip weak ones rather than saving noise. Still run duplicate + stale checks before write.
+3. Record saved `docs/knowledge/` paths (or explicitly "nothing worth saving").
+
+## Step 5: DONE
+
+Output a self-contained recap:
+
+```
+<promise>DONE</promise>
+
+**LFG complete.**
+
+Plan: [plan_path]
+Deliverables:
+- [path or title]
+Learnings:
+- [docs/knowledge/... | none]
+
+Residuals / watch-outs:
+- [remaining P2s, blockers, or assumptions]
+```
+
+Do not open a PR or push git remotes — knowledge work ends at deliverables + compounded knowledge. If the project wants git commits, the user (or a separate CE `/lfg`) owns that.
+
+---
+
+## Important Rules
+
+* **Hands-off between stages.** The whole point is not asking "plan or work next?" after brainstorm. Interactive steering belongs in the individual `/kw:*` skills.
+* **Plan before work.** Never invent an execution path without a written plan file (unless `plan:` was provided).
+* **P1 is a hard gate.** Wrong strategy or wrong data must not silently ship.
+* **Compound closes the loop.** Skipping Step 4 means the next cycle cannot benefit — only skip when Step 3 produced nothing meaningful.
+* **Brainstorm stays interactive.** LFG does not replace `/kw:brainstorm`; it consumes its output (or a topic) and runs the rest.
+
+## Relationship to Compound Engineering `/lfg`
+
+| | CE `/lfg` | CK `/kw:lfg` |
+|--|-----------|--------------|
+| Domain | Software | Knowledge work |
+| Core pipeline | plan → work → simplify → code-review → PR → CI | plan → review → work → compound |
+| Terminal artifact | Open PR (often CI-green) | Deliverables + `docs/knowledge/` entries |
+| Typical entry | Feature description or requirements plan | Brainstorm origin doc, topic, or existing plan |

From e19245fcf3d92b1b7403b2cfb3ef553b2e568887 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 09:14:32 -0700
Subject: [PATCH 3/9] feat: strengthen brainstorm/plan/review stage handoffs

---
 .../skills/kw-brainstorm/SKILL.md             | 48 +++++++++++++++----
 .../skills/kw-plan/SKILL.md                   | 35 +++++++++++---
 .../skills/kw-review/SKILL.md                 | 27 +++++++++--
 3 files changed, 90 insertions(+), 20 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
index a1bab31..93b5ebb 100644
--- a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
@@ -10,6 +10,15 @@ argument-hint: "[topic, brain dump, or meeting notes]"
 
 Get everything out of your head and into one place. Pull in references. Find the shape of the problem before you commit to a plan.
 
+## Stage Orientation
+
+Stay oriented in the loop. Do not silently morph into planning or execution.
+
+* On the first response of this skill, open with: **Stage: Brainstorm**
+* Keep responses clearly inside brainstorm until Step 7 completes
+* Never start `/kw:plan`, `/kw:work`, or writing a full plan unless the user picks that next step (or `/kw:lfg`)
+* When Step 7 runs, say **Brainstorm complete** before the menu — never skip the handoff
+
 ## When to Use
 
 * After a meeting where next steps need to be figured out
@@ -172,28 +181,49 @@ Based on everything — including the resolved questions from Step 5 — offer a
 
 This is a suggestion, not a decision. The user decides.
 
-### Step 7: Offer next steps
+### Step 7: Handoff — never skip
+
+Brainstorm is done when Steps 1–6 are complete. **Do not keep chatting inside brainstorm without a handoff.** Present the next-step menu every time.
+
+Preamble (always show first):
+
+```
+**Brainstorm complete.**
+
+Origin doc: plans/brainstorm-{descriptive-name}.md   # after write; omit if not yet saved
 
-Use AskUserQuestion:
+What would you like to do next?
+```
 
-**Question:** "Brainstorm captured. What next?"
+Use AskUserQuestion when available. If AskUserQuestion is unavailable on this host, render the same options as a numbered list in chat and wait for a reply. **Never silently skip this question.**
 
 **Options:**
 
-1. **Run `/kw:plan`** — Structure this into an actionable plan
-2. **Dig deeper** — Research a specific theme or question further
-3. **Push to Proof** — Share the brainstorm for team feedback
-4. **Save and continue later** — Write to `plans/brainstorm-{descriptive-name}.md`
-5. **Keep going** — Add more context or refine the themes
+1. **Create the plan** *(recommended)* — Hand off to `/kw:plan` and structure this into an actionable plan
+2. **Ship the loop with `/kw:lfg`** — Hands-off: plan → review → work → compound with no check-ins between stages. Best when the direction is clear and you want deliverables without steering each stage.
+3. **Dig deeper** — Research a specific theme or question further, then return to this menu
+4. **Push to Proof** — Share the brainstorm for team feedback
+5. **Save and continue later** — Write the origin doc and stop
+6. **Keep going** — Add more context or refine themes, then return to this menu
 
 <critical_requirement>
-If "Save" or "Run /kw:plan" is selected: ALWAYS write the brainstorm to `plans/brainstorm-{descriptive-name}.md` first. This file becomes the origin document that `/kw:plan` will search for. Never skip the file write.
+If option 1, 2, or 5 is selected: ALWAYS write the brainstorm to `plans/brainstorm-{descriptive-name}.md` first. This file becomes the origin document that `/kw:plan` and `/kw:lfg` use. Never skip the file write.
 </critical_requirement>
 
+#### Handle the selected option
+
+* **Create the plan:** After writing the origin doc, immediately load the `kw:plan` skill in this session, passing the brainstorm path. Do not wait for the user to type `/kw:plan`.
+* **Ship the loop with `/kw:lfg`:** After writing the origin doc, immediately load the `kw:lfg` skill with that path. Do not ask which stage to run next — LFG owns the rest of the loop.
+* **Dig deeper / Keep going:** Continue brainstorm dialogue, then return to this Step 7 menu when ready. Do not jump to planning.
+* **Save and continue later:** Write the origin doc, show the path, and end the turn with a one-line next step (`/kw:plan` or `/kw:lfg` when they return).
+* **Push to Proof:** Share, then re-present this menu.
+
 ## Important Rules
 
 * **Don't jump to solutions.** The point of brainstorming is to understand the problem space before committing to a path. Resist the urge to plan.
 
+* **Handoff is mandatory.** Ending brainstorm without Step 7 leaves the user lost about whether they are still brainstorming or already planning. Always present the menu.
+
 * **Reflect, don't rewrite.** When summarizing back, use the user's language. Don't sanitize their thinking into corporate speak.
 
 * **Surface tensions early, resolve the load-bearing ones late.** Steps 2-4 are for naming conflicts without picking winners. Step 5 is for resolving only the ones that would change the plan's shape. Don't collapse tensions prematurely.
diff --git a/plugins/compound-knowledge/skills/kw-plan/SKILL.md b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
index dbc96c0..02e76c1 100644
--- a/plugins/compound-knowledge/skills/kw-plan/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
@@ -10,6 +10,13 @@ argument-hint: "[what to plan]"
 
 Research what you already know, then structure a plan grounded in data and past learnings. Lead with the answer.
 
+## Stage Orientation
+
+* On the first response of this skill, open with: **Stage: Plan**
+* Stay in planning until Step 6 — do not start executing deliverables here
+* When the plan file is written, say **Plan complete** before the handoff menu
+* If the user wants hands-off execution of the rest of the loop, offer `/kw:lfg` rather than silently chaining
+
 ## When to Use
 
 * After brainstorming, when you're ready to commit to a direction
@@ -294,19 +301,33 @@ Use the template that matches the work type from Step 1. Each type has a differe
 
 * Always write the file BEFORE presenting options.
 
-### Step 6: Offer next steps
+### Step 6: Handoff — never skip
+
+```
+**Plan complete.**
+
+Plan: plans/{filename}
 
-Use AskUserQuestion:
+What would you like to do next?
+```
 
-**Question:** "Plan written to `plans/{filename}`. What next?"
+Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
 
 **Options:**
 
-1. **Run `/kw:review`** — Check strategic alignment and data accuracy
+1. **Run `/kw:review`** *(recommended)* — Check strategic alignment and data accuracy before executing
 2. **Start `/kw:work`** — Begin executing this plan
-3. **Push to Proof** — Share the plan for collaborative review
-4. **Refine** — Adjust specific sections
-5. **Open in editor** — View the full plan
+3. **Ship the rest with `/kw:lfg`** — Hands-off from here: review → work → compound (skips re-planning; uses this plan)
+4. **Push to Proof** — Share the plan for collaborative review
+5. **Refine** — Adjust specific sections, then return to this menu
+6. **Open in editor** — View the full plan
+
+#### Handle the selected option
+
+* **Run `/kw:review`:** Immediately load `kw:review` with the plan path.
+* **Start `/kw:work`:** Immediately load `kw:work` with the plan path.
+* **Ship the rest with `/kw:lfg`:** Immediately load `kw:lfg` with `plan:<path>` so it starts at review (does not re-run plan).
+* **Refine:** Edit the plan, then re-present this menu.
 
 ## Important Rules
 
diff --git a/plugins/compound-knowledge/skills/kw-review/SKILL.md b/plugins/compound-knowledge/skills/kw-review/SKILL.md
index 50a164c..92b17b4 100644
--- a/plugins/compound-knowledge/skills/kw-review/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-review/SKILL.md
@@ -10,6 +10,12 @@ argument-hint: "[file path or content to review]"
 
 Two automated reviewers check your work for the errors that damage credibility: wrong strategy and wrong data.
 
+## Stage Orientation
+
+* On the first response of this skill, open with: **Stage: Review**
+* Stay in review until findings are presented and the handoff runs
+* When done, say **Review complete** before the next-step menu
+
 ## When to Use
 
 * After `/kw:plan` to validate a plan before executing
@@ -95,20 +101,33 @@ Combine findings from both reviewers. Group all findings by severity:
 | **P2 Important** | Missing source citation, stale data, unclear success metric              | "Conversion rate has no comparison basis" |
 | **P3 Nice-to-have**                                                     | Minor framing, additional context, formatting                            | "Could specify the time period for this metric"                                                  |
 
-### Step 5: Offer next steps
+### Step 5: Handoff — never skip
+
+```
+**Review complete.**
+
+Findings: [N] ([P1 count] critical, [P2 count] important, [P3 count] nice-to-have)
 
-Use AskUserQuestion:
+What would you like to do next?
+```
 
-**Question:** "Review complete. \[N] findings (\[P1 count] critical, \[P2 count] important). What next?"
+Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
 
 **Options:**
 
 1. **Fix P1/P2 issues now** — Address findings inline, then re-review
-2. **Run `/kw:work`** — Plan passes. Start executing it
+2. **Run `/kw:work`** *(recommended when no P1s)* — Plan passes. Start executing it
 3. **Run `/kw:compound`** — Save review insights as learnings
 4. **Push to Proof** — Share review findings for discussion
 5. **Ship as-is** — Acknowledge findings and proceed without fixing
 
+#### Handle the selected option
+
+* **Fix P1/P2:** Apply fixes to the artifact, then re-run review (return to Step 2).
+* **Run `/kw:work`:** Immediately load `kw:work` with the reviewed plan/artifact path.
+* **Run `/kw:compound`:** Immediately load `kw:compound`.
+* If P1 findings remain, recommend fixing before work — still allow the user to override.
+
 ## Important Rules
 
 * **P1 = hard gate.** A factual error in a strategy doc is worse than a typo. Say so clearly.

From 4a53e361889658c28012aac1d47b98233925ae01 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 09:15:40 -0700
Subject: [PATCH 4/9] feat: strengthen work/compound/confidence stage handoffs

---
 .../skills/kw-compound/SKILL.md               | 23 ++++++++++----
 .../skills/kw-confidence/SKILL.md             |  5 +++
 .../skills/kw-work/SKILL.md                   | 31 +++++++++++++++----
 3 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-compound/SKILL.md b/plugins/compound-knowledge/skills/kw-compound/SKILL.md
index 2b8df14..b830019 100644
--- a/plugins/compound-knowledge/skills/kw-compound/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-compound/SKILL.md
@@ -7,6 +7,11 @@ description: Extract and save learnings from a completed knowledge work session.
 
 Close the loop. Extract what you learned and save it where future work will find it.
 
+## Stage Orientation
+
+* On the first response of this skill, open with: **Stage: Compound**
+* When learnings are saved (or none are worth saving), say **Loop closed** before the final menu
+
 ## When to Use
 
 * After completing a plan, campaign, analysis, or strategy session
@@ -129,27 +134,33 @@ source: [brief description of what triggered this]
 [How this should change future work. Be concrete: "When doing X, always check Y first."]
 ```
 
-### Step 5: Confirm and offer next steps
+### Step 5: Confirm and handoff
 
 ```
-## Compounded
+**Loop closed.**
 
 **Saved:**
-- docs/knowledge/{filename}.md
+- docs/knowledge/{filename}.md   # or "Nothing new to save"
 
-**This learning will be surfaced by /kw:plan** when future work touches:
+**These learnings will be surfaced by /kw:plan** when future work touches:
 - [list the tags that would trigger retrieval]
 ```
 
-Use AskUserQuestion:
+Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
 
 **Question:** "Learnings saved. What next?"
 
 **Options:**
-1. **Run `/kw:plan`** — Start a new planning cycle (the learnings will be found)
+
+1. **Run `/kw:brainstorm` or `/kw:plan`** — Start a new cycle (learnings will be found)
 2. **Push to Proof** — Share the learnings for team review
 3. **Done** — Session complete
 
+#### Handle the selected option
+
+* **New cycle:** Immediately load `kw:brainstorm` or `kw:plan` as the user prefers (default to plan if they name a concrete next topic).
+* **Done:** End with a one-line reminder that knowledge is in `docs/knowledge/`.
+
 ## Important Rules
 
 * **1-3 learnings max per session.** If you're saving 5 things, you're not filtering enough.
diff --git a/plugins/compound-knowledge/skills/kw-confidence/SKILL.md b/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
index 40ff830..aa845ac 100644
--- a/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
@@ -7,6 +7,11 @@ description: Gut-check what you know and don't know before proceeding. Use at an
 
 Pause and honestly say what you're confident about and what you're not — like a colleague would. Then decide whether to proceed or dig deeper.
 
+## Stage Orientation
+
+* On the first response, open with: **Stage: Confidence** (interrupt — does not replace the parent stage)
+* After the check, explicitly re-anchor: e.g. "Resuming **Stage: Work**" or "Return to **Stage: Plan** handoff"
+
 ## When to Use
 
 * Before committing to a plan or starting execution
diff --git a/plugins/compound-knowledge/skills/kw-work/SKILL.md b/plugins/compound-knowledge/skills/kw-work/SKILL.md
index 6ea231e..d6b8ac2 100644
--- a/plugins/compound-knowledge/skills/kw-work/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-work/SKILL.md
@@ -10,6 +10,12 @@ argument-hint: "[plan file to execute]"
 
 You have a plan. Now execute it. Break it into tasks, do them, track what happened.
 
+## Stage Orientation
+
+* On the first response of this skill, open with: **Stage: Work**
+* This is execution — produce deliverables, do not rewrite the whole plan
+* When batches finish, say **Execution complete** before the handoff menu
+
 ## When to Use
 
 * After `/kw:plan` or `/kw:review` — the plan is ready, time to execute
@@ -171,19 +177,32 @@ When all tasks are complete (or blocked), summarize:
 - [anything learned during execution worth noting]
 ```
 
-### Step 8: Offer next steps
+### Step 8: Handoff — never skip
+
+```
+**Execution complete.**
+
+Plan: [plan name]
+Deliverables: [N] produced
 
-Use AskUserQuestion:
+What would you like to do next?
+```
 
-**Question:** "Execution complete. \[N] deliverables produced. What next?"
+Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
 
 **Options:**
 
-1. **Run `/kw:review`** — Quality check the outputs
-2. **Run `/kw:compound`** — Save learnings from this session
+1. **Run `/kw:compound`** *(recommended)* — Save learnings from this session so the next cycle starts smarter
+2. **Run `/kw:review`** — Quality check the outputs
 3. **Push to Proof** — Share execution summary for review
 4. **Continue working** — Pick up blocked tasks or add new ones
-5. **Ship it** — Done, move on
+5. **Ship it** — Done for now; skip compounding (not recommended after meaningful work)
+
+#### Handle the selected option
+
+* **Run `/kw:compound`:** Immediately load `kw:compound`, pointing at this session's plan + execution log.
+* **Run `/kw:review`:** Immediately load `kw:review` on the primary deliverable or plan.
+* **Continue working:** Return to Step 4 for remaining/blocked work, then return to this menu.
 
 ## Important Rules
 

From 1fcb803c09eddce93174fabeb70ce6d5e265efe7 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:20:11 -0700
Subject: [PATCH 5/9] =?UTF-8?q?fix(skills):=20CE=20review=20=E2=80=94=20As?=
 =?UTF-8?q?kUserQuestion=204-option=20cap=20and=20handoff=20handlers?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../skills/kw-brainstorm/SKILL.md             | 244 +-----------
 .../skills/kw-plan/SKILL.md                   | 353 +-----------------
 2 files changed, 2 insertions(+), 595 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
index 93b5ebb..e681624 100644
--- a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
@@ -1,243 +1 @@
----
-name: kw:brainstorm
-description: Brain dump and compile knowledge before structuring a plan. Use when starting any non-trivial knowledge work — after a meeting, when tackling a new problem, or when you need to pull together what you know before planning.
-argument-hint: "[topic, brain dump, or meeting notes]"
----
-
-<brain_dump> #$ARGUMENTS </brain_dump>
-
-# Brainstorm
-
-Get everything out of your head and into one place. Pull in references. Find the shape of the problem before you commit to a plan.
-
-## Stage Orientation
-
-Stay oriented in the loop. Do not silently morph into planning or execution.
-
-* On the first response of this skill, open with: **Stage: Brainstorm**
-* Keep responses clearly inside brainstorm until Step 7 completes
-* Never start `/kw:plan`, `/kw:work`, or writing a full plan unless the user picks that next step (or `/kw:lfg`)
-* When Step 7 runs, say **Brainstorm complete** before the menu — never skip the handoff
-
-## When to Use
-
-* After a meeting where next steps need to be figured out
-
-* Starting a new project, campaign, or strategy
-
-* "I need to think through X", "Let me brain dump", "Help me figure this out"
-
-* When you have scattered inputs (notes, docs, transcripts) that need organizing
-
-## Process
-
-### Step 1: Capture the brain dump
-
-Accept whatever the user gives you. This might be:
-
-* A pasted meeting transcript
-
-* A voice-to-text dump
-
-* Bullet points and half-formed thoughts
-
-* A link to a document
-
-* "Here's what I'm thinking about..."
-
-**Do not organize yet.** Just acknowledge what you received and identify what type of input it is.
-
-If the user hasn't given you anything yet, prompt:
-
-> "What are you working on? You can paste meeting notes, describe the problem, or just start talking. I'll help organize it."
-
-### Step 2: Extract the core elements
-
-From the brain dump, pull out:
-
-* **Key decisions** that need to be made
-
-* **Open questions** that don't have answers yet
-
-* **Constraints** (timeline, budget, dependencies, blockers)
-
-* **Stakeholders** and what they care about
-
-* **Data points** mentioned (numbers, metrics, references)
-
-* **Ideas and options** that were floated (even half-baked ones)
-
-Present these back as a structured summary:
-
-```
-## What I Heard
-
-**The problem:** [One sentence — what are we trying to figure out?]
-
-**Decisions to make:**
-- [Decision 1]
-- [Decision 2]
-
-**Open questions:**
-- [Question 1]
-- [Question 2]
-
-**Constraints:**
-- [Timeline, budget, dependencies]
-
-**Stakeholders:**
-- [Who] — [what they care about]
-
-**Ideas floated:**
-- [Idea 1] — [brief note on pros/cons if mentioned]
-- [Idea 2]
-
-**Data points mentioned:**
-- [Any numbers, metrics, or references cited]
-```
-
-### Step 3: Pull in references (automatic + optional)
-
-<parallel_tasks>
-
-**Automatic searches** — Run these without asking:
-
-- Search `docs/knowledge/` for learnings related to the brain dump topics
-- Search `plans/` for related past plans
-- Search `docs/solutions/` for relevant patterns
-
-</parallel_tasks>
-
-For each source found:
-
-```
-**Found:** [source name/path]
-**Relevant because:** [one sentence]
-**Key takeaway:** [the useful bit]
-```
-
-If nothing relevant is found: "No prior context found in knowledge base or plans."
-
-**Optional search** — After presenting automatic findings, offer:
-
-> "Want me to search externally too? (web, specific documents, other sources)"
-
-If nothing relevant is found, say so. Don't fabricate context.
-
-### Step 4: Identify themes and tensions
-
-Look across everything — the brain dump, the extracted elements, and the references — and identify:
-
-* **Themes** — What keeps coming up? What's the real underlying question?
-
-* **Tensions** — Where do ideas conflict? Where are there tradeoffs?
-
-* **Gaps** — What's missing? What hasn't been addressed?
-
-```
-## Themes
-1. [Theme] — [why it matters]
-2. [Theme] — [why it matters]
-
-## Tensions
-- [Option A] vs [Option B] — [the tradeoff]
-
-## Gaps
-- [What we don't know yet]
-- [What needs more research]
-```
-
-### Step 5: Resolve load-bearing questions
-
-Before moving toward a direction, take the open questions and tensions from Step 2 and Step 4 and identify which ones are **load-bearing** — meaning the plan's structure would change depending on the answer.
-
-Ignore nice-to-know questions. Focus only on ones where different answers lead to different plans. Common load-bearing questions:
-
-- **Scope:** "Is this a quick win or a multi-phase initiative?"
-- **Audience:** "Who is this for? That changes everything downstream."
-- **Priority:** "You mentioned X and Y — which matters more if we have to choose?"
-- **Timeline:** "Are we talking days, weeks, or months?"
-- **Owner:** "Who's making the final call on this?"
-- **Constraints:** "Is there a budget/resource ceiling I should plan around?"
-
-Use AskUserQuestion to ask **1-3 load-bearing questions at once** (never more than 3). Frame each question with options drawn from what surfaced in the brainstorm — don't ask open-ended questions when you already have candidate answers.
-
-Example:
-
-> **Question:** "You mentioned both 'grow trials' and 'improve conversion' — which is the primary goal?"
-> **Options:** Grow trials (top of funnel) / Improve conversion (bottom of funnel) / Both equally
-
-If all open questions are non-load-bearing (i.e., any answer leads to roughly the same plan), skip this step and say so:
-
-> "The open questions won't change the plan's shape — we can resolve them during execution."
-
-**Important:** This step is a bridge, not an interrogation. 1-3 questions max. The goal is to give `/kw:plan` clean inputs, not to turn brainstorming into a requirements gathering session.
-
-### Step 6: Suggest a direction
-
-Based on everything — including the resolved questions from Step 5 — offer a point of view:
-
-> "Based on what I'm seeing, the core question is [X]. The main tension is between [A] and [B]. My suggestion would be to [direction] because [reasoning]. But [caveat]."
-
-This is a suggestion, not a decision. The user decides.
-
-### Step 7: Handoff — never skip
-
-Brainstorm is done when Steps 1–6 are complete. **Do not keep chatting inside brainstorm without a handoff.** Present the next-step menu every time.
-
-Preamble (always show first):
-
-```
-**Brainstorm complete.**
-
-Origin doc: plans/brainstorm-{descriptive-name}.md   # after write; omit if not yet saved
-
-What would you like to do next?
-```
-
-Use AskUserQuestion when available. If AskUserQuestion is unavailable on this host, render the same options as a numbered list in chat and wait for a reply. **Never silently skip this question.**
-
-**Options:**
-
-1. **Create the plan** *(recommended)* — Hand off to `/kw:plan` and structure this into an actionable plan
-2. **Ship the loop with `/kw:lfg`** — Hands-off: plan → review → work → compound with no check-ins between stages. Best when the direction is clear and you want deliverables without steering each stage.
-3. **Dig deeper** — Research a specific theme or question further, then return to this menu
-4. **Push to Proof** — Share the brainstorm for team feedback
-5. **Save and continue later** — Write the origin doc and stop
-6. **Keep going** — Add more context or refine themes, then return to this menu
-
-<critical_requirement>
-If option 1, 2, or 5 is selected: ALWAYS write the brainstorm to `plans/brainstorm-{descriptive-name}.md` first. This file becomes the origin document that `/kw:plan` and `/kw:lfg` use. Never skip the file write.
-</critical_requirement>
-
-#### Handle the selected option
-
-* **Create the plan:** After writing the origin doc, immediately load the `kw:plan` skill in this session, passing the brainstorm path. Do not wait for the user to type `/kw:plan`.
-* **Ship the loop with `/kw:lfg`:** After writing the origin doc, immediately load the `kw:lfg` skill with that path. Do not ask which stage to run next — LFG owns the rest of the loop.
-* **Dig deeper / Keep going:** Continue brainstorm dialogue, then return to this Step 7 menu when ready. Do not jump to planning.
-* **Save and continue later:** Write the origin doc, show the path, and end the turn with a one-line next step (`/kw:plan` or `/kw:lfg` when they return).
-* **Push to Proof:** Share, then re-present this menu.
-
-## Important Rules
-
-* **Don't jump to solutions.** The point of brainstorming is to understand the problem space before committing to a path. Resist the urge to plan.
-
-* **Handoff is mandatory.** Ending brainstorm without Step 7 leaves the user lost about whether they are still brainstorming or already planning. Always present the menu.
-
-* **Reflect, don't rewrite.** When summarizing back, use the user's language. Don't sanitize their thinking into corporate speak.
-
-* **Surface tensions early, resolve the load-bearing ones late.** Steps 2-4 are for naming conflicts without picking winners. Step 5 is for resolving only the ones that would change the plan's shape. Don't collapse tensions prematurely.
-
-* **Pull, don't push.** Ask where references might live rather than guessing. The user knows their information landscape better than you do.
-
-* **Quantity of input is fine.** A 30-minute meeting transcript is good input. Don't ask people to pre-organize before brainstorming — that defeats the purpose.
-
-## Pipeline Mode
-
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
-
-- Skip all AskUserQuestion prompts
-- Use sensible defaults for all choices
-- Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+PLACEHOLDER_USE_FILE
\ No newline at end of file
diff --git a/plugins/compound-knowledge/skills/kw-plan/SKILL.md b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
index 02e76c1..311c8dd 100644
--- a/plugins/compound-knowledge/skills/kw-plan/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
@@ -1,352 +1 @@
----
-name: kw:plan
-description: Research past work and structure a knowledge work plan. Use when starting strategy docs, campaign plans, content briefs, research synthesis, or operational playbooks.
-argument-hint: "[what to plan]"
----
-
-<plan_request> #$ARGUMENTS </plan_request>
-
-# Plan
-
-Research what you already know, then structure a plan grounded in data and past learnings. Lead with the answer.
-
-## Stage Orientation
-
-* On the first response of this skill, open with: **Stage: Plan**
-* Stay in planning until Step 6 — do not start executing deliverables here
-* When the plan file is written, say **Plan complete** before the handoff menu
-* If the user wants hands-off execution of the rest of the loop, offer `/kw:lfg` rather than silently chaining
-
-## When to Use
-
-* After brainstorming, when you're ready to commit to a direction
-
-* Starting a new strategy doc, campaign plan, or brief
-
-* "Plan the March campaign", "I need a brief for X", "Let's structure this"
-
-* Any non-trivial knowledge work that benefits from past context
-
-## Process
-
-### Step 1: Classify the work type (auto-detect, don't ask)
-
-Determine the work type from the user's description:
-
-| Type           | Signals                                          |
-| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
-| **Strategy**   | Roadmap, architecture, long-term, layers, phases |
-| **Campaign**   | Launch, promotion, timeline, channels, audience  |
-| **Brief**      | Directive for someone else, scope, deliverables  |
-| **Research**   | Investigation, competitive, analysis, synthesis  |
-| **Operations** | Playbook, runbook, SOP, recurring process        |
-
-Pick the best fit and proceed. Do not ask the user to classify.
-
-Also determine the **detail tier** from scope signals:
-
-| Tier | Signals | Output |
-|------|---------|--------|
-| **Quick** | "should we?", "gut check", single question, <30 min scope | Title, recommendation, 2-3 bullets of reasoning, one success metric |
-| **Standard** | Default — most plans | Full template for the work type |
-| **Deep** | "restructure", "strategy", "multi-quarter", "fundamental" | Full template + research appendix, competitive analysis, risk matrix, phased timeline |
-
-Pick the best fit. Default to Standard if unclear.
-
-### Step 2: Research (parallel agents + inline)
-
-Launch research agents in parallel. Each returns structured findings — they do NOT write files.
-
-<parallel_tasks>
-
-**2a. Past work** — Launch Task agent: `compound-knowledge:research:past-work-researcher`
-- Pass: the plan request description + work type from Step 1
-- Returns: related plans, prior decisions, origin brainstorm documents
-
-**2b. Knowledge base** — Launch Task agent: `compound-knowledge:research:knowledge-base-researcher`
-- Pass: the plan request description + keywords
-- Returns: saved learnings from docs/knowledge/ (insights, corrections, playbooks, patterns)
-
-**2c. External research** (inline, not an agent) — If the topic would benefit from outside context:
-- Search the web for frameworks, best practices, competitive examples
-- Only run if the topic is outward-facing or novel — skip for internal operations
-
-</parallel_tasks>
-
-**2d. Live data** — Pull current metrics if the plan involves data. Follow whatever data hierarchy exists in the project's CLAUDE.md. If none exists, ask the user where to find relevant data.
-
-**2e. Origin document check** — Search for `plans/brainstorm-*.md` files matching this topic. If found, this brainstorm is the origin document — reference it throughout the plan as `(see origin: plans/brainstorm-{name}.md)` and cross-check that the plan addresses tensions and load-bearing questions from the brainstorm.
-
-Wait for all parallel tasks to complete before proceeding.
-
-### Step 3: Surface what you already know
-
-Before writing anything, present a context brief:
-
-```
-## What I Found
-
-**Related plans:**
-- [plan name] — [one-line summary of what's relevant]
-
-**Past learnings:**
-- [learning title] — [the insight]
-
-**Current data:**
-- [metric]: [value] ([source, date])
-
-**External research:**
-- [finding] — [source]
-
-**No prior context found** (if searches returned nothing)
-```
-
-Wait for the user to react. They may refine direction, add context, or say "looks good, go."
-
-### Step 4: Structure the plan
-
-Use the template that matches the work type from Step 1. Each type has a different lead section — use the right one. Fill sections based on research findings. Skip sections that aren't relevant.
-
-**All templates share these common sections** (include at the bottom of every plan):
-
-```markdown
-## Success Metrics
-
-| Metric | Current Baseline | Target | Source |
-|--------|-----------------|--------|--------|
-| [Primary metric] | [value] | [goal] | [where to measure] |
-
-## Open Questions
-
-- [What we don't know yet]
-- [Decisions that need to be made]
-
-## References
-
-- [Related plans, knowledge entries, data sources used]
-```
-
-***
-
-**Strategy** — Pyramid Principle. Lead with the recommendation.
-
-```markdown
-# [Plan Title]
-
-**Type:** Strategy
-**Status:** Draft
-**Created:** [today's date]
-
----
-
-## Recommendation
-
-[One paragraph: what we should do and why. Lead with the answer.]
-
-## Current State
-
-[What's true right now. Data from Step 2d. Source and date for every number.]
-
-## Proposed Approach
-
-[How to get from current state to the desired outcome. Layers or phases.]
-```
-
-***
-
-**Campaign** — Timeline-first. Lead with what launches when.
-
-```markdown
-# [Plan Title]
-
-**Type:** Campaign
-**Status:** Draft
-**Created:** [today's date]
-
----
-
-## Timeline
-
-| Date/Week | Action | Channel | Owner |
-|-----------|--------|---------|-------|
-| [date] | [what launches] | [where] | [who] |
-
-## Goal
-
-[One paragraph: what this campaign achieves and how we'll know it worked.]
-
-## Audience
-
-[Who this targets. Segment, persona, or behavioral description.]
-
-## Assets Needed
-
-- [Copy, creative, landing pages, emails — what needs to be produced]
-
-## Current State
-
-[Relevant baselines. What are the numbers before we start?]
-```
-
-***
-
-**Brief** — Directive-first. Lead with the recommendation, then scope.
-
-```markdown
-# [Plan Title]
-
-**Type:** Brief
-**Status:** Draft
-**Created:** [today's date]
-
----
-
-## Recommendation
-
-[One paragraph: what we should do and why. Lead with the answer.]
-
-## Scope
-
-[What's in and what's out. Be explicit about boundaries.]
-
-## Deliverables
-
-- [Concrete output 1]
-- [Concrete output 2]
-
-## Constraints
-
-[Timeline, budget, dependencies, blockers.]
-
-## Context
-
-[Background the reader needs. Data from Step 2d.]
-```
-
-***
-
-**Research** — Findings-first. Lead with what you discovered.
-
-```markdown
-# [Plan Title]
-
-**Type:** Research
-**Status:** Draft
-**Created:** [today's date]
-
----
-
-## Key Findings
-
-1. **[Finding]** — [One sentence with data. Source and date.]
-2. **[Finding]** — [One sentence with data. Source and date.]
-3. **[Finding]** — [One sentence with data. Source and date.]
-
-## Implications
-
-[What these findings mean for the business. What should change.]
-
-## Methodology
-
-[How you gathered this data. Sources, timeframes, filters, caveats.]
-
-## Raw Data
-
-[Tables, charts, or links to dashboards that support the findings.]
-```
-
-***
-
-**Operations** — Trigger-first. Lead with when this runs and what to do.
-
-```markdown
-# [Plan Title]
-
-**Type:** Operations
-**Status:** Draft
-**Created:** [today's date]
-
----
-
-## Trigger
-
-[When does this process run? On a schedule, on an event, on request?]
-
-## Steps
-
-1. [Step] — [details, tools, commands]
-2. [Step] — [details, tools, commands]
-3. [Step] — [details, tools, commands]
-
-## Edge Cases
-
-| Situation | What to do |
-|-----------|-----------|
-| [When X happens] | [Do Y] |
-
-## Owner
-
-[Who runs this. Who to escalate to.]
-
-## Dependencies
-
-[What this process needs to work — access, tools, data sources.]
-```
-
-### Step 5: Write to plans/
-
-* Filename: `plans/{type}-{descriptive-name}.md`
-
-* If filename already exists, append date: `plans/{type}-{name}-{YYYY-MM-DD}.md`
-
-* Always write the file BEFORE presenting options.
-
-### Step 6: Handoff — never skip
-
-```
-**Plan complete.**
-
-Plan: plans/{filename}
-
-What would you like to do next?
-```
-
-Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
-
-**Options:**
-
-1. **Run `/kw:review`** *(recommended)* — Check strategic alignment and data accuracy before executing
-2. **Start `/kw:work`** — Begin executing this plan
-3. **Ship the rest with `/kw:lfg`** — Hands-off from here: review → work → compound (skips re-planning; uses this plan)
-4. **Push to Proof** — Share the plan for collaborative review
-5. **Refine** — Adjust specific sections, then return to this menu
-6. **Open in editor** — View the full plan
-
-#### Handle the selected option
-
-* **Run `/kw:review`:** Immediately load `kw:review` with the plan path.
-* **Start `/kw:work`:** Immediately load `kw:work` with the plan path.
-* **Ship the rest with `/kw:lfg`:** Immediately load `kw:lfg` with `plan:<path>` so it starts at review (does not re-run plan).
-* **Refine:** Edit the plan, then re-present this menu.
-
-## Important Rules
-
-* **Lead with what the reader needs first.** Strategy/Brief: the recommendation. Campaign: the timeline. Research: the findings. Operations: the trigger and steps. If someone only reads the first section, they should get the most important thing.
-
-* **Cite everything.** Every data point needs a source. "+32% WoW" not "+32%".
-
-* **Surface past work.** The whole point is that knowledge compounds. If related plans or learnings exist, they MUST appear in the context brief.
-
-* **Don't over-template.** The template is a starting point. Skip sections that don't apply. A campaign plan doesn't need an "Architecture" section.
-
-* **Degrade gracefully.** If a data source fails or returns nothing, proceed with what you have. Note what's missing.
-
-## Pipeline Mode
-
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
-
-- Skip all AskUserQuestion prompts
-- Use sensible defaults for all choices
-- Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+PLACEHOLDER
\ No newline at end of file

From aa09cc924eda78674f3c5360f0b3708753b79ba2 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:21:57 -0700
Subject: [PATCH 6/9] =?UTF-8?q?fix(skills):=20CE=20review=20=E2=80=94=20mo?=
 =?UTF-8?q?de:pipeline=20carrier,=20compound=20auto-save,=20LFG=20path=20p?=
 =?UTF-8?q?arsing?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../skills/kw-compound/SKILL.md               | 27 +++++----
 .../skills/kw-confidence/SKILL.md             | 13 +++--
 .../compound-knowledge/skills/kw-lfg/SKILL.md | 55 +++++++++++--------
 3 files changed, 56 insertions(+), 39 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-compound/SKILL.md b/plugins/compound-knowledge/skills/kw-compound/SKILL.md
index b830019..ccdfd54 100644
--- a/plugins/compound-knowledge/skills/kw-compound/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-compound/SKILL.md
@@ -63,7 +63,7 @@ Show each learning with its classification. User can:
 
 * Add learnings you missed
 
-**Do not save anything without approval.**
+**Do not save anything without approval** in interactive mode. **In `mode:pipeline`:** skip the approval prompt; auto-approve 1–3 high-signal learnings after duplicate + stale checks (still skip weak/noisy candidates).
 
 ### Step 3: Check for duplicates
 
@@ -146,26 +146,33 @@ source: [brief description of what triggered this]
 - [list the tags that would trigger retrieval]
 ```
 
-Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options.
+
+* If visible count ≤ 4 **and** AskUserQuestion is available → use AskUserQuestion
+* If visible count > 4, or AskUserQuestion is unavailable / errors → numbered list in chat with "Pick a number or describe what you want."
+* **Never** call AskUserQuestion with more than 4 options. **Never** silently skip this question.
 
 **Question:** "Learnings saved. What next?"
 
 **Options:**
 
-1. **Run `/kw:brainstorm` or `/kw:plan`** — Start a new cycle (learnings will be found)
-2. **Push to Proof** — Share the learnings for team review
+1. **Run `/kw:plan`** — Start a new planning cycle (learnings will be found)
+2. **Run `/kw:brainstorm`** — Start a fresh brainstorm
 3. **Done** — Session complete
+4. **Push to Proof** — Share the learnings for team review, then re-present this menu
 
 #### Handle the selected option
 
-* **New cycle:** Immediately load `kw:brainstorm` or `kw:plan` as the user prefers (default to plan if they name a concrete next topic).
+* **Run `/kw:plan`:** Immediately load `kw:plan`.
+* **Run `/kw:brainstorm`:** Immediately load `kw:brainstorm`.
 * **Done:** End with a one-line reminder that knowledge is in `docs/knowledge/`.
+* **Push to Proof:** Share, then re-present this menu.
 
 ## Important Rules
 
 * **1-3 learnings max per session.** If you're saving 5 things, you're not filtering enough.
 
-* **Approval required.** Never auto-save. The user decides what's worth remembering.
+* **Approval required (interactive).** Never auto-save when a user is in the loop. **Pipeline exception:** when invoked with `mode:pipeline` (e.g. from `/kw:lfg`), auto-save after duplicate + stale checks per Pipeline Mode — quality filter still applies (1–3 max).
 
 * **Be specific.** "Use the right data source" is useless. "Revenue metrics come from [specific dashboard], not [other source] which overcounts by ~$X" is useful.
 
@@ -177,10 +184,10 @@ Use AskUserQuestion when available; otherwise a numbered list in chat. **Never s
 
 ## Pipeline Mode
 
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
 
-- Skip all AskUserQuestion prompts
+- Skip all AskUserQuestion prompts and interactive waits (including "wait for the user to react" / batch approvals)
 - Use sensible defaults for all choices
 - Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse
diff --git a/plugins/compound-knowledge/skills/kw-confidence/SKILL.md b/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
index aa845ac..013fe09 100644
--- a/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
@@ -9,8 +9,9 @@ Pause and honestly say what you're confident about and what you're not — like
 
 ## Stage Orientation
 
-* On the first response, open with: **Stage: Confidence** (interrupt — does not replace the parent stage)
-* After the check, explicitly re-anchor: e.g. "Resuming **Stage: Work**" or "Return to **Stage: Plan** handoff"
+* On entry, capture the parent stage/skill/step if one is active, then open with: **Stage: Confidence** (interrupt — does not replace the parent stage). Example: "Interrupting **Stage: Work** (Batch 2)."
+* After the check, on **Proceed**, must re-anchor with the captured parent banner (e.g. "Resuming **Stage: Work**") and continue that skill — do not restart it.
+* Offering `/kw:plan` mid-interrupt leaves the parent stage; say so explicitly before loading it.
 
 ## When to Use
 
@@ -153,10 +154,10 @@ Then continue where you left off. The confidence check is a non-destructive inte
 
 ## Pipeline Mode
 
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
 
-- Skip all AskUserQuestion prompts
+- Skip all AskUserQuestion prompts and interactive waits (including "wait for the user to react" / batch approvals)
 - Use sensible defaults for all choices
 - Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse
diff --git a/plugins/compound-knowledge/skills/kw-lfg/SKILL.md b/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
index 75e51fa..07abdb3 100644
--- a/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: kw:lfg
-description: "Run the full Compound Knowledge loop end-to-end, hands-off with no check-ins between stages. Use only when the user explicitly asks to ship the knowledge-work loop autonomously (plan → review → work → compound), or invokes /kw:lfg directly. Not for in-the-loop work where the user reviews each stage — use /kw:plan, /kw:review, /kw:work, or /kw:compound instead."
-argument-hint: "[topic, brainstorm path, or plan:<path> to skip planning]"
+description: "Run the full Compound Knowledge loop end-to-end, hands-off with no check-ins between stages. Use only when the user explicitly asks to ship the rest of the knowledge-work loop autonomously (plan → review → work → compound), or invokes /kw:lfg directly. Not for in-the-loop work where the user reviews each stage — use /kw:plan, /kw:review, /kw:work, or /kw:compound instead."
+argument-hint: "[topic | brainstorm path | plan path | plan:<path>]"
 ---
 
 <lfg_request> #$ARGUMENTS </lfg_request>
@@ -12,26 +12,29 @@ Run the Compound Knowledge loop autonomously: **plan → review → work → com
 
 This is the knowledge-work counterpart to Compound Engineering's `/lfg`. CE ships code to an open PR; CK ships knowledge deliverables and compounds learnings into `docs/knowledge/`.
 
-CRITICAL: Execute every step below **in order**. Do not jump ahead to `/kw:work` before a plan exists (unless invoked with `plan:<path>`). Do not ask "what next?" between stages.
+CRITICAL: Execute every step below **in order**. Do not jump ahead to `/kw:work` before a plan exists (unless a plan path was provided). Do not ask "what next?" between stages.
 
 Resolve every skill named below against the host's available-skills list and invoke that exact entry (hosts may namespace it, e.g. `compound-knowledge:kw-plan`).
 
 ## When to Use
 
-* User says "just run the loop", "lfg", "ship it", or picks **Ship the loop with `/kw:lfg`** from a brainstorm/plan handoff
+* User says "just run the loop", "lfg", "ship the rest", or picks **Ship the rest with `/kw:lfg`** from a brainstorm/plan handoff
 * Direction is clear enough that mid-loop steering is optional
 * **Not** for exploratory brainstorming — finish `/kw:brainstorm` interactively first, then LFG
 
 ## Inputs
 
-Parse `$ARGUMENTS`:
+Parse `$ARGUMENTS` in this order:
 
 | Form | Meaning |
 |------|---------|
-| `plan:plans/...md` or `plan:<path>` | Skip Step 1. Use this plan; start at review. |
-| Path to `plans/brainstorm-*.md` | Origin doc for planning. |
+| `plan:<path>` | Skip Step 1. Use this plan; start at review. |
+| Existing file under `plans/` matching `brainstorm-*.md` | Origin doc for planning. |
+| Existing file under `plans/` that is **not** a brainstorm (e.g. `plans/strategy-….md`) | Treat as an existing plan — skip Step 1; start at review (same as `plan:`). |
 | Free-text topic | Plan from the topic (and any prior conversation context). |
-| Empty | Use the most recent brainstorm in `plans/`, else the active conversation topic. If neither exists, STOP and tell the user what to pass. |
+| Empty | Use the most recent brainstorm in `plans/`, else the most recent non-brainstorm plan, else the active conversation topic. If none exist, STOP and tell the user what to pass. |
+
+If a path looks like a plan file but does not exist, STOP and report — do not invent a plan silently.
 
 ## Stage narration
 
@@ -45,43 +48,47 @@ After each step, one line naming what it produced (plan path, P1 count, delivera
 
 ## Pipeline contract
 
-When invoking child skills, run them in **Pipeline Mode**:
+When invoking child skills, pass **`mode:pipeline`** in the invocation arguments (plus the plan/brainstorm path or topic). That carrier is the durable signal — do **not** rely on `disable-model-invocation` (that is skill frontmatter for blocking invocation, not a runtime mode).
+
+Child skills under `mode:pipeline` must:
+
+* Skip AskUserQuestion and interactive waits
+* Write files without waiting
+* **Return structured results only** — they must **not** load the next `/kw:*` skill themselves
+* Still follow non-interactive Important Rules (cite sources, write execution logs, quality filters)
 
-* Pass context equivalent to `disable-model-invocation` / pipeline so they skip AskUserQuestion
-* Use sensible defaults; write files without waiting
-* Do **not** present their interactive handoff menus — LFG owns progression
-* Child skills still follow their Important Rules (cite sources, write execution logs, etc.)
+LFG alone advances stages after each child returns.
 
 ---
 
 ## Step 1: Plan
 
-**Skip** if invoked with `plan:<path>` and that file exists.
+**Skip** if a plan path was resolved from inputs (`plan:` or existing non-brainstorm `plans/*.md`).
 
-1. Invoke `kw:plan` on the brainstorm path or topic.
+1. Invoke `kw:plan` with `mode:pipeline` on the brainstorm path or topic.
 2. GATE: STOP if no plan file was written. Report why and halt.
 3. **Record `plan_path`** for later steps.
 
 ## Step 2: Review
 
-1. Invoke `kw:review` on `plan_path`.
+1. Invoke `kw:review` with `mode:pipeline` on `plan_path`.
 2. If **P1** findings exist:
    - Attempt a single auto-fix pass on the plan (and any attached brief) addressing each P1
-   - Re-run `kw:review` once
+   - Re-run `kw:review` once with `mode:pipeline`
    - If P1s remain: GATE STOP. Report remaining P1s and `plan_path`. Do not execute a plan with unresolved critical findings unless the user later overrides interactively.
 3. P2/P3 findings: note them in narration; continue (apply obvious safe P2 fixes when cheap; otherwise leave for compound/residuals).
 
 ## Step 3: Work
 
-1. Invoke `kw:work` on `plan_path`.
-2. In pipeline mode: skip per-batch approval prompts; still write the **Execution Log** into the plan file after each batch.
+1. Invoke `kw:work` with `mode:pipeline` on `plan_path`.
+2. Child skips per-batch approval prompts; still writes the **Execution Log** into the plan file after each batch.
 3. GATE: STOP if zero deliverables were produced and work is blocked on missing access/info the agent cannot resolve. Report blockers and `plan_path`.
 4. **Record deliverable paths** for the close-out.
 
 ## Step 4: Compound
 
-1. Invoke `kw:compound` against this session (plan + execution log + deliverables).
-2. In pipeline mode: auto-approve **1–3** high-signal learnings; skip weak ones rather than saving noise. Still run duplicate + stale checks before write.
+1. Invoke `kw:compound` with `mode:pipeline` against this session (plan + execution log + deliverables).
+2. Pipeline compound auto-approves **1–3** high-signal learnings after duplicate + stale checks; skips weak ones rather than saving noise.
 3. Record saved `docs/knowledge/` paths (or explicitly "nothing worth saving").
 
 ## Step 5: DONE
@@ -103,17 +110,18 @@ Residuals / watch-outs:
 - [remaining P2s, blockers, or assumptions]
 ```
 
-Do not open a PR or push git remotes — knowledge work ends at deliverables + compounded knowledge. If the project wants git commits, the user (or a separate CE `/lfg`) owns that.
+Terminal artifacts are **deliverables + compounded knowledge** — not a git PR/CI green. If the project wants commits or a PR, the user (or Compound Engineering `/lfg`) owns that separately.
 
 ---
 
 ## Important Rules
 
 * **Hands-off between stages.** The whole point is not asking "plan or work next?" after brainstorm. Interactive steering belongs in the individual `/kw:*` skills.
-* **Plan before work.** Never invent an execution path without a written plan file (unless `plan:` was provided).
+* **Plan before work.** Never invent an execution path without a written plan file (unless a plan path was provided).
 * **P1 is a hard gate.** Wrong strategy or wrong data must not silently ship.
 * **Compound closes the loop.** Skipping Step 4 means the next cycle cannot benefit — only skip when Step 3 produced nothing meaningful.
 * **Brainstorm stays interactive.** LFG does not replace `/kw:brainstorm`; it consumes its output (or a topic) and runs the rest.
+* **LFG owns the chain.** Children in `mode:pipeline` return to LFG; they do not self-chain.
 
 ## Relationship to Compound Engineering `/lfg`
 
@@ -123,3 +131,4 @@ Do not open a PR or push git remotes — knowledge work ends at deliverables + c
 | Core pipeline | plan → work → simplify → code-review → PR → CI | plan → review → work → compound |
 | Terminal artifact | Open PR (often CI-green) | Deliverables + `docs/knowledge/` entries |
 | Typical entry | Feature description or requirements plan | Brainstorm origin doc, topic, or existing plan |
+| Runtime carrier | `mode:pipeline` / return-to-caller | `mode:pipeline` on each child invoke |

From e7714acef3b79c2c69337cc160fa66b3492fb8c2 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:23:28 -0700
Subject: [PATCH 7/9] =?UTF-8?q?fix(skills):=20CE=20review=20=E2=80=94=20As?=
 =?UTF-8?q?kUserQuestion=204-option=20cap=20and=20handoff=20handlers=20(br?=
 =?UTF-8?q?ainstorm,=20plan)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../skills/kw-brainstorm/SKILL.md             | 248 +++++++++++-
 .../skills/kw-plan/SKILL.md                   | 359 +++++++++++++++++-
 2 files changed, 605 insertions(+), 2 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
index e681624..d95bed4 100644
--- a/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
@@ -1 +1,247 @@
-PLACEHOLDER_USE_FILE
\ No newline at end of file
+---
+name: kw:brainstorm
+description: Brain dump and compile knowledge before structuring a plan. Use when starting any non-trivial knowledge work — after a meeting, when tackling a new problem, or when you need to pull together what you know before planning.
+argument-hint: "[topic, brain dump, or meeting notes]"
+---
+
+<brain_dump> #$ARGUMENTS </brain_dump>
+
+# Brainstorm
+
+Get everything out of your head and into one place. Pull in references. Find the shape of the problem before you commit to a plan.
+
+## Stage Orientation
+
+Stay oriented in the loop. Do not silently morph into planning or execution.
+
+* On the first response of this skill, open with: **Stage: Brainstorm**
+* Keep responses clearly inside brainstorm until Step 7 completes
+* Never start `/kw:plan`, `/kw:work`, or writing a full plan unless the user picks that next step (or `/kw:lfg`)
+* When Step 7 runs, say **Brainstorm complete** before the menu — never skip the handoff
+
+## When to Use
+
+* After a meeting where next steps need to be figured out
+
+* Starting a new project, campaign, or strategy
+
+* "I need to think through X", "Let me brain dump", "Help me figure this out"
+
+* When you have scattered inputs (notes, docs, transcripts) that need organizing
+
+## Process
+
+### Step 1: Capture the brain dump
+
+Accept whatever the user gives you. This might be:
+
+* A pasted meeting transcript
+
+* A voice-to-text dump
+
+* Bullet points and half-formed thoughts
+
+* A link to a document
+
+* "Here's what I'm thinking about..."
+
+**Do not organize yet.** Just acknowledge what you received and identify what type of input it is.
+
+If the user hasn't given you anything yet, prompt:
+
+> "What are you working on? You can paste meeting notes, describe the problem, or just start talking. I'll help organize it."
+
+### Step 2: Extract the core elements
+
+From the brain dump, pull out:
+
+* **Key decisions** that need to be made
+
+* **Open questions** that don't have answers yet
+
+* **Constraints** (timeline, budget, dependencies, blockers)
+
+* **Stakeholders** and what they care about
+
+* **Data points** mentioned (numbers, metrics, references)
+
+* **Ideas and options** that were floated (even half-baked ones)
+
+Present these back as a structured summary:
+
+```
+## What I Heard
+
+**The problem:** [One sentence — what are we trying to figure out?]
+
+**Decisions to make:**
+- [Decision 1]
+- [Decision 2]
+
+**Open questions:**
+- [Question 1]
+- [Question 2]
+
+**Constraints:**
+- [Timeline, budget, dependencies]
+
+**Stakeholders:**
+- [Who] — [what they care about]
+
+**Ideas floated:**
+- [Idea 1] — [brief note on pros/cons if mentioned]
+- [Idea 2]
+
+**Data points mentioned:**
+- [Any numbers, metrics, or references cited]
+```
+
+### Step 3: Pull in references (automatic + optional)
+
+<parallel_tasks>
+
+**Automatic searches** — Run these without asking:
+
+- Search `docs/knowledge/` for learnings related to the brain dump topics
+- Search `plans/` for related past plans
+- Search `docs/solutions/` for relevant patterns
+
+</parallel_tasks>
+
+For each source found:
+
+```
+**Found:** [source name/path]
+**Relevant because:** [one sentence]
+**Key takeaway:** [the useful bit]
+```
+
+If nothing relevant is found: "No prior context found in knowledge base or plans."
+
+**Optional search** — After presenting automatic findings, offer:
+
+> "Want me to search externally too? (web, specific documents, other sources)"
+
+If nothing relevant is found, say so. Don't fabricate context.
+
+### Step 4: Identify themes and tensions
+
+Look across everything — the brain dump, the extracted elements, and the references — and identify:
+
+* **Themes** — What keeps coming up? What's the real underlying question?
+
+* **Tensions** — Where do ideas conflict? Where are there tradeoffs?
+
+* **Gaps** — What's missing? What hasn't been addressed?
+
+```
+## Themes
+1. [Theme] — [why it matters]
+2. [Theme] — [why it matters]
+
+## Tensions
+- [Option A] vs [Option B] — [the tradeoff]
+
+## Gaps
+- [What we don't know yet]
+- [What needs more research]
+```
+
+### Step 5: Resolve load-bearing questions
+
+Before moving toward a direction, take the open questions and tensions from Step 2 and Step 4 and identify which ones are **load-bearing** — meaning the plan's structure would change depending on the answer.
+
+Ignore nice-to-know questions. Focus only on ones where different answers lead to different plans. Common load-bearing questions:
+
+- **Scope:** "Is this a quick win or a multi-phase initiative?"
+- **Audience:** "Who is this for? That changes everything downstream."
+- **Priority:** "You mentioned X and Y — which matters more if we have to choose?"
+- **Timeline:** "Are we talking days, weeks, or months?"
+- **Owner:** "Who's making the final call on this?"
+- **Constraints:** "Is there a budget/resource ceiling I should plan around?"
+
+Use AskUserQuestion to ask **1-3 load-bearing questions at once** (never more than 3). Frame each question with options drawn from what surfaced in the brainstorm — don't ask open-ended questions when you already have candidate answers.
+
+Example:
+
+> **Question:** "You mentioned both 'grow trials' and 'improve conversion' — which is the primary goal?"
+> **Options:** Grow trials (top of funnel) / Improve conversion (bottom of funnel) / Both equally
+
+If all open questions are non-load-bearing (i.e., any answer leads to roughly the same plan), skip this step and say so:
+
+> "The open questions won't change the plan's shape — we can resolve them during execution."
+
+**Important:** This step is a bridge, not an interrogation. 1-3 questions max. The goal is to give `/kw:plan` clean inputs, not to turn brainstorming into a requirements gathering session.
+
+### Step 6: Suggest a direction
+
+Based on everything — including the resolved questions from Step 5 — offer a point of view:
+
+> "Based on what I'm seeing, the core question is [X]. The main tension is between [A] and [B]. My suggestion would be to [direction] because [reasoning]. But [caveat]."
+
+This is a suggestion, not a decision. The user decides.
+
+### Step 7: Handoff — never skip
+
+Brainstorm is done when Steps 1–6 are complete. **Do not keep chatting inside brainstorm without a handoff.** Present the next-step menu every time.
+
+Preamble (always show first):
+
+```
+**Brainstorm complete.**
+
+Origin doc: <absolute-or-workspace path to plans/brainstorm-{descriptive-name}.md>   # after write; omit if not yet saved
+
+What would you like to do next?
+```
+
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options. Count the visible options below for the current state:
+
+* If visible count ≤ 4 **and** AskUserQuestion is available → use AskUserQuestion
+* If visible count > 4, or AskUserQuestion is unavailable / errors → render a numbered list in chat with "Pick a number or describe what you want."
+* **Never** call AskUserQuestion with more than 4 options. **Never** silently skip this question.
+
+**Options** (renumber contiguous when any are hidden):
+
+1. **Create the plan** *(recommended)* — Hand off to `/kw:plan` and structure this into an actionable plan
+2. **Ship the rest with `/kw:lfg`** — Hands-off from here: plan → review → work → compound (no stage check-ins). Shown only when Step 5 resolved load-bearing questions (or none were load-bearing). If load-bearing items remain open, hide this option and tell the user to resolve them or pick Create the plan.
+3. **Dig deeper** — Research a specific theme or question further, then return to this menu (re-print **Stage: Brainstorm**)
+4. **Save and continue later** — Write the origin doc and stop
+5. **Keep going** — Add more context or refine themes, then return to this menu
+6. **Push to Proof** — Share the brainstorm for team feedback, then re-present this menu
+
+<critical_requirement>
+If option 1, 2, or 4 is selected: ALWAYS write the brainstorm to `plans/brainstorm-{descriptive-name}.md` first. This file becomes the origin document that `/kw:plan` and `/kw:lfg` use. Never skip the file write.
+</critical_requirement>
+
+#### Handle the selected option
+
+* **Create the plan:** After writing the origin doc, immediately load the `kw:plan` skill in this session, passing the brainstorm path. Do not wait for the user to type `/kw:plan`.
+* **Ship the rest with `/kw:lfg`:** After writing the origin doc, immediately load the `kw:lfg` skill with that path. Do not ask which stage to run next — LFG owns the rest of the loop.
+* **Dig deeper / Keep going:** Continue brainstorm dialogue (keep **Stage: Brainstorm**), then return to this Step 7 menu when ready. Do not jump to planning or write plan-shaped outlines.
+* **Save and continue later:** Write the origin doc, show the path, and end the turn with a one-line next step (`/kw:plan` or `/kw:lfg` when they return).
+* **Push to Proof:** Share, then re-present this menu.
+
+## Important Rules
+
+* **Don't jump to solutions.** The point of brainstorming is to understand the problem space before committing to a path. Resist the urge to plan.
+
+* **Handoff is mandatory.** Ending brainstorm without Step 7 leaves the user lost about whether they are still brainstorming or already planning. Always present the menu.
+
+* **Reflect, don't rewrite.** When summarizing back, use the user's language. Don't sanitize their thinking into corporate speak.
+
+* **Surface tensions early, resolve the load-bearing ones late.** Steps 2-4 are for naming conflicts without picking winners. Step 5 is for resolving only the ones that would change the plan's shape. Don't collapse tensions prematurely.
+
+* **Pull, don't push.** Ask where references might live rather than guessing. The user knows their information landscape better than you do.
+
+* **Quantity of input is fine.** A 30-minute meeting transcript is good input. Don't ask people to pre-organize before brainstorming — that defeats the purpose.
+
+## Pipeline Mode
+
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
+
+- Skip all AskUserQuestion prompts and interactive waits
+- Use sensible defaults for all choices
+- Write output files without waiting for confirmation
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse (origin path, themes, open questions)
diff --git a/plugins/compound-knowledge/skills/kw-plan/SKILL.md b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
index 311c8dd..c946e82 100644
--- a/plugins/compound-knowledge/skills/kw-plan/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
@@ -1 +1,358 @@
-PLACEHOLDER
\ No newline at end of file
+---
+name: kw:plan
+description: Research past work and structure a knowledge work plan. Use when starting strategy docs, campaign plans, content briefs, research synthesis, or operational playbooks.
+argument-hint: "[what to plan]"
+---
+
+<plan_request> #$ARGUMENTS </plan_request>
+
+# Plan
+
+Research what you already know, then structure a plan grounded in data and past learnings. Lead with the answer.
+
+## Stage Orientation
+
+* On the first response of this skill, open with: **Stage: Plan**
+* Stay in planning until Step 6 — do not start executing deliverables here
+* When the plan file is written, say **Plan complete** before the handoff menu
+* If the user wants hands-off execution of the rest of the loop, offer `/kw:lfg` rather than silently chaining
+
+## When to Use
+
+* After brainstorming, when you're ready to commit to a direction
+
+* Starting a new strategy doc, campaign plan, or brief
+
+* "Plan the March campaign", "I need a brief for X", "Let's structure this"
+
+* Any non-trivial knowledge work that benefits from past context
+
+## Process
+
+### Step 1: Classify the work type (auto-detect, don't ask)
+
+Determine the work type from the user's description:
+
+| Type           | Signals                                          |
+| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| **Strategy**   | Roadmap, architecture, long-term, layers, phases |
+| **Campaign**   | Launch, promotion, timeline, channels, audience  |
+| **Brief**      | Directive for someone else, scope, deliverables  |
+| **Research**   | Investigation, competitive, analysis, synthesis  |
+| **Operations** | Playbook, runbook, SOP, recurring process        |
+
+Pick the best fit and proceed. Do not ask the user to classify.
+
+Also determine the **detail tier** from scope signals:
+
+| Tier | Signals | Output |
+|------|---------|--------|
+| **Quick** | "should we?", "gut check", single question, <30 min scope | Title, recommendation, 2-3 bullets of reasoning, one success metric |
+| **Standard** | Default — most plans | Full template for the work type |
+| **Deep** | "restructure", "strategy", "multi-quarter", "fundamental" | Full template + research appendix, competitive analysis, risk matrix, phased timeline |
+
+Pick the best fit. Default to Standard if unclear.
+
+### Step 2: Research (parallel agents + inline)
+
+Launch research agents in parallel. Each returns structured findings — they do NOT write files.
+
+<parallel_tasks>
+
+**2a. Past work** — Launch Task agent: `compound-knowledge:research:past-work-researcher`
+- Pass: the plan request description + work type from Step 1
+- Returns: related plans, prior decisions, origin brainstorm documents
+
+**2b. Knowledge base** — Launch Task agent: `compound-knowledge:research:knowledge-base-researcher`
+- Pass: the plan request description + keywords
+- Returns: saved learnings from docs/knowledge/ (insights, corrections, playbooks, patterns)
+
+**2c. External research** (inline, not an agent) — If the topic would benefit from outside context:
+- Search the web for frameworks, best practices, competitive examples
+- Only run if the topic is outward-facing or novel — skip for internal operations
+
+</parallel_tasks>
+
+**2d. Live data** — Pull current metrics if the plan involves data. Follow whatever data hierarchy exists in the project's CLAUDE.md. If none exists, ask the user where to find relevant data.
+
+**2e. Origin document check** — Search for `plans/brainstorm-*.md` files matching this topic. If found, this brainstorm is the origin document — reference it throughout the plan as `(see origin: plans/brainstorm-{name}.md)` and cross-check that the plan addresses tensions and load-bearing questions from the brainstorm.
+
+Wait for all parallel tasks to complete before proceeding.
+
+### Step 3: Surface what you already know
+
+Before writing anything, present a context brief:
+
+```
+## What I Found
+
+**Related plans:**
+- [plan name] — [one-line summary of what's relevant]
+
+**Past learnings:**
+- [learning title] — [the insight]
+
+**Current data:**
+- [metric]: [value] ([source, date])
+
+**External research:**
+- [finding] — [source]
+
+**No prior context found** (if searches returned nothing)
+```
+
+Wait for the user to react. They may refine direction, add context, or say "looks good, go." **Skip this wait entirely in `mode:pipeline`** — present the brief in narration and continue to Step 4.
+
+### Step 4: Structure the plan
+
+Use the template that matches the work type from Step 1. Each type has a different lead section — use the right one. Fill sections based on research findings. Skip sections that aren't relevant.
+
+**All templates share these common sections** (include at the bottom of every plan):
+
+```markdown
+## Success Metrics
+
+| Metric | Current Baseline | Target | Source |
+|--------|-----------------|--------|--------|
+| [Primary metric] | [value] | [goal] | [where to measure] |
+
+## Open Questions
+
+- [What we don't know yet]
+- [Decisions that need to be made]
+
+## References
+
+- [Related plans, knowledge entries, data sources used]
+```
+
+***
+
+**Strategy** — Pyramid Principle. Lead with the recommendation.
+
+```markdown
+# [Plan Title]
+
+**Type:** Strategy
+**Status:** Draft
+**Created:** [today's date]
+
+---
+
+## Recommendation
+
+[One paragraph: what we should do and why. Lead with the answer.]
+
+## Current State
+
+[What's true right now. Data from Step 2d. Source and date for every number.]
+
+## Proposed Approach
+
+[How to get from current state to the desired outcome. Layers or phases.]
+```
+
+***
+
+**Campaign** — Timeline-first. Lead with what launches when.
+
+```markdown
+# [Plan Title]
+
+**Type:** Campaign
+**Status:** Draft
+**Created:** [today's date]
+
+---
+
+## Timeline
+
+| Date/Week | Action | Channel | Owner |
+|-----------|--------|---------|-------|
+| [date] | [what launches] | [where] | [who] |
+
+## Goal
+
+[One paragraph: what this campaign achieves and how we'll know it worked.]
+
+## Audience
+
+[Who this targets. Segment, persona, or behavioral description.]
+
+## Assets Needed
+
+- [Copy, creative, landing pages, emails — what needs to be produced]
+
+## Current State
+
+[Relevant baselines. What are the numbers before we start?]
+```
+
+***
+
+**Brief** — Directive-first. Lead with the recommendation, then scope.
+
+```markdown
+# [Plan Title]
+
+**Type:** Brief
+**Status:** Draft
+**Created:** [today's date]
+
+---
+
+## Recommendation
+
+[One paragraph: what we should do and why. Lead with the answer.]
+
+## Scope
+
+[What's in and what's out. Be explicit about boundaries.]
+
+## Deliverables
+
+- [Concrete output 1]
+- [Concrete output 2]
+
+## Constraints
+
+[Timeline, budget, dependencies, blockers.]
+
+## Context
+
+[Background the reader needs. Data from Step 2d.]
+```
+
+***
+
+**Research** — Findings-first. Lead with what you discovered.
+
+```markdown
+# [Plan Title]
+
+**Type:** Research
+**Status:** Draft
+**Created:** [today's date]
+
+---
+
+## Key Findings
+
+1. **[Finding]** — [One sentence with data. Source and date.]
+2. **[Finding]** — [One sentence with data. Source and date.]
+3. **[Finding]** — [One sentence with data. Source and date.]
+
+## Implications
+
+[What these findings mean for the business. What should change.]
+
+## Methodology
+
+[How you gathered this data. Sources, timeframes, filters, caveats.]
+
+## Raw Data
+
+[Tables, charts, or links to dashboards that support the findings.]
+```
+
+***
+
+**Operations** — Trigger-first. Lead with when this runs and what to do.
+
+```markdown
+# [Plan Title]
+
+**Type:** Operations
+**Status:** Draft
+**Created:** [today's date]
+
+---
+
+## Trigger
+
+[When does this process run? On a schedule, on an event, on request?]
+
+## Steps
+
+1. [Step] — [details, tools, commands]
+2. [Step] — [details, tools, commands]
+3. [Step] — [details, tools, commands]
+
+## Edge Cases
+
+| Situation | What to do |
+|-----------|-----------|
+| [When X happens] | [Do Y] |
+
+## Owner
+
+[Who runs this. Who to escalate to.]
+
+## Dependencies
+
+[What this process needs to work — access, tools, data sources.]
+```
+
+### Step 5: Write to plans/
+
+* Filename: `plans/{type}-{descriptive-name}.md`
+
+* If filename already exists, append date: `plans/{type}-{name}-{YYYY-MM-DD}.md`
+
+* Always write the file BEFORE presenting options.
+
+### Step 6: Handoff — never skip
+
+```
+**Plan complete.**
+
+Plan: <absolute-or-workspace path to plans/{filename}>
+
+What would you like to do next?
+```
+
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options.
+
+* If visible count ≤ 4 **and** AskUserQuestion is available → use AskUserQuestion
+* If visible count > 4, or AskUserQuestion is unavailable / errors → numbered list in chat with "Pick a number or describe what you want."
+* **Never** call AskUserQuestion with more than 4 options. **Never** silently skip this question.
+
+**Options:**
+
+1. **Run `/kw:review`** *(recommended)* — Check strategic alignment and data accuracy before executing
+2. **Start `/kw:work`** — Begin executing this plan
+3. **Ship the rest with `/kw:lfg`** — Hands-off from here: review → work → compound (skips re-planning; uses this plan)
+4. **Refine** — Adjust specific sections, then return to this menu
+5. **Push to Proof** — Share the plan for collaborative review, then re-present this menu
+6. **Open in editor** — Show the plan path for local viewing, then re-present this menu
+
+#### Handle the selected option
+
+* **Run `/kw:review`:** Immediately load `kw:review` with the plan path.
+* **Start `/kw:work`:** Immediately load `kw:work` with the plan path.
+* **Ship the rest with `/kw:lfg`:** Immediately load `kw:lfg` with `plan:<path>` (or the plan file path) so it starts at review — does not re-run plan.
+* **Refine:** Edit the plan, then re-present this menu.
+* **Push to Proof:** Share, then re-present this menu.
+* **Open in editor:** Display the plan path (open via host primitive if available), then re-present this menu.
+
+## Important Rules
+
+* **Lead with what the reader needs first.** Strategy/Brief: the recommendation. Campaign: the timeline. Research: the findings. Operations: the trigger and steps. If someone only reads the first section, they should get the most important thing.
+
+* **Cite everything.** Every data point needs a source. "+32% WoW" not "+32%".
+
+* **Surface past work.** The whole point is that knowledge compounds. If related plans or learnings exist, they MUST appear in the context brief.
+
+* **Don't over-template.** The template is a starting point. Skip sections that don't apply. A campaign plan doesn't need an "Architecture" section.
+
+* **Degrade gracefully.** If a data source fails or returns nothing, proceed with what you have. Note what's missing.
+
+## Pipeline Mode
+
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
+
+- Skip all AskUserQuestion prompts and interactive waits (including "wait for the user to react" / batch approvals)
+- Use sensible defaults for all choices
+- Write output files without waiting for confirmation
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse

From c6293a76a7725198dcf83844cd6c55cac2a8fa52 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:24:16 -0700
Subject: [PATCH 8/9] =?UTF-8?q?fix(skills):=20CE=20review=20=E2=80=94=20As?=
 =?UTF-8?q?kUserQuestion=204-option=20cap=20and=20handoff=20handlers=20(re?=
 =?UTF-8?q?view,=20work)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../skills/kw-review/SKILL.md                 | 20 +++++++++-----
 .../skills/kw-work/SKILL.md                   | 26 ++++++++++++-------
 2 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/plugins/compound-knowledge/skills/kw-review/SKILL.md b/plugins/compound-knowledge/skills/kw-review/SKILL.md
index 92b17b4..85f0944 100644
--- a/plugins/compound-knowledge/skills/kw-review/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-review/SKILL.md
@@ -111,21 +111,27 @@ Findings: [N] ([P1 count] critical, [P2 count] important, [P3 count] nice-to-hav
 What would you like to do next?
 ```
 
-Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options.
+
+* If visible count ≤ 4 **and** AskUserQuestion is available → use AskUserQuestion
+* If visible count > 4, or AskUserQuestion is unavailable / errors → numbered list in chat with "Pick a number or describe what you want."
+* **Never** call AskUserQuestion with more than 4 options. **Never** silently skip this question.
 
 **Options:**
 
 1. **Fix P1/P2 issues now** — Address findings inline, then re-review
 2. **Run `/kw:work`** *(recommended when no P1s)* — Plan passes. Start executing it
 3. **Run `/kw:compound`** — Save review insights as learnings
-4. **Push to Proof** — Share review findings for discussion
-5. **Ship as-is** — Acknowledge findings and proceed without fixing
+4. **Ship as-is** — Acknowledge findings and load `/kw:work` without fixing
+5. **Push to Proof** — Share review findings for discussion, then re-present this menu
 
 #### Handle the selected option
 
 * **Fix P1/P2:** Apply fixes to the artifact, then re-run review (return to Step 2).
 * **Run `/kw:work`:** Immediately load `kw:work` with the reviewed plan/artifact path.
 * **Run `/kw:compound`:** Immediately load `kw:compound`.
+* **Ship as-is:** Acknowledge remaining findings in one line, then immediately load `kw:work` with the plan path (same as work; note any remaining P1 override).
+* **Push to Proof:** Share, then re-present this menu.
 * If P1 findings remain, recommend fixing before work — still allow the user to override.
 
 ## Important Rules
@@ -142,10 +148,10 @@ Use AskUserQuestion when available; otherwise a numbered list in chat. **Never s
 
 ## Pipeline Mode
 
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
 
-- Skip all AskUserQuestion prompts
+- Skip all AskUserQuestion prompts and interactive waits (including "wait for the user to react" / batch approvals)
 - Use sensible defaults for all choices
 - Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse
diff --git a/plugins/compound-knowledge/skills/kw-work/SKILL.md b/plugins/compound-knowledge/skills/kw-work/SKILL.md
index d6b8ac2..48b9e69 100644
--- a/plugins/compound-knowledge/skills/kw-work/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-work/SKILL.md
@@ -49,6 +49,8 @@ Present the task list to the user:
 
 > "I see \[N] deliverables in this plan. Here's how I'd break them down. Want to adjust before I start?"
 
+**In `mode:pipeline`:** present the task list in narration and continue — do not wait for adjustment.
+
 **Task types in knowledge work:**
 
 | Deliverable          | How to execute                               |
@@ -101,7 +103,7 @@ Present the execution plan to the user:
 1. **Announce the batch** — "Starting Batch 1: \[task names]"
 2. **Launch independent tasks in parallel** — Use Task agents for tasks that don't depend on each other. For single tasks or tasks requiring heavy interaction, execute inline.
 3. **Show all outputs** — Present results from the batch together
-4. **Get feedback** — "Good? Or adjust before I move to Batch 2?"
+4. **Get feedback** — "Good? Or adjust before I move to Batch 2?" (**Skip in `mode:pipeline`** — log results and continue to the next batch.)
 5. **Mark complete** — Move to next batch
 
 **When to parallelize within a batch:**
@@ -188,21 +190,27 @@ Deliverables: [N] produced
 What would you like to do next?
 ```
 
-Use AskUserQuestion when available; otherwise a numbered list in chat. **Never silently skip this question.**
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options.
+
+* If visible count ≤ 4 **and** AskUserQuestion is available → use AskUserQuestion
+* If visible count > 4, or AskUserQuestion is unavailable / errors → numbered list in chat with "Pick a number or describe what you want."
+* **Never** call AskUserQuestion with more than 4 options. **Never** silently skip this question.
 
 **Options:**
 
 1. **Run `/kw:compound`** *(recommended)* — Save learnings from this session so the next cycle starts smarter
 2. **Run `/kw:review`** — Quality check the outputs
-3. **Push to Proof** — Share execution summary for review
-4. **Continue working** — Pick up blocked tasks or add new ones
-5. **Ship it** — Done for now; skip compounding (not recommended after meaningful work)
+3. **Continue working** — Pick up blocked tasks or add new ones
+4. **Done for now** — End without compounding (not recommended after meaningful work)
+5. **Push to Proof** — Share execution summary for review, then re-present this menu
 
 #### Handle the selected option
 
 * **Run `/kw:compound`:** Immediately load `kw:compound`, pointing at this session's plan + execution log.
 * **Run `/kw:review`:** Immediately load `kw:review` on the primary deliverable or plan.
 * **Continue working:** Return to Step 4 for remaining/blocked work, then return to this menu.
+* **Done for now:** End the turn; note that `/kw:compound` can still run later on this plan's execution log.
+* **Push to Proof:** Share, then re-present this menu.
 
 ## Important Rules
 
@@ -218,10 +226,10 @@ Use AskUserQuestion when available; otherwise a numbered list in chat. **Never s
 
 ## Pipeline Mode
 
-When invoked with `disable-model-invocation` context (e.g., from an orchestrator or automation):
+When invoked with `mode:pipeline` in arguments (or equivalent pipeline/orchestrator context):
 
-- Skip all AskUserQuestion prompts
+- Skip all AskUserQuestion prompts and interactive waits (including "wait for the user to react" / batch approvals)
 - Use sensible defaults for all choices
 - Write output files without waiting for confirmation
-- Proceed to the next suggested skill automatically
-- Output structured results that the calling context can parse
+- **Do not** load the next skill yourself — return structured results to the caller (e.g. `/kw:lfg`) which owns progression
+- Output structured results the calling context can parse

From 4e1940d132195ef13bcc0abbae20d8a674777684 Mon Sep 17 00:00:00 2001
From: crowlede <5617703+crowlede@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:25:18 -0700
Subject: [PATCH 9/9] =?UTF-8?q?docs:=20CE=20review=20=E2=80=94=20changelog?=
 =?UTF-8?q?,=20AGENTS,=20READMEs=20for=20stage=20handoffs=20and=20LFG?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                               | 2 +-
 plugins/compound-knowledge/AGENTS.md    | 4 +++-
 plugins/compound-knowledge/CHANGELOG.md | 6 +++++-
 plugins/compound-knowledge/README.md    | 2 +-
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 8471823..cb1473f 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ Read the story: [How to Build a Command Center That Keeps You Sane](https://ever
 
 Each cycle makes the next one faster. `/kw:plan` searches `docs/knowledge/` for past learnings saved by `/kw:compound`. Knowledge compounds.
 
-After `/kw:brainstorm`, you get an explicit handoff — create a plan, or ship the rest of the loop with `/kw:lfg` — so you don't lose track of which stage you're in.
+After `/kw:brainstorm`, you get an explicit handoff — create a plan, or **Ship the rest** with `/kw:lfg` — so you don't lose track of which stage you're in.
 
 ## Install
 
diff --git a/plugins/compound-knowledge/AGENTS.md b/plugins/compound-knowledge/AGENTS.md
index a8f7512..720f9e5 100644
--- a/plugins/compound-knowledge/AGENTS.md
+++ b/plugins/compound-knowledge/AGENTS.md
@@ -41,7 +41,9 @@ compound-knowledge/
 
 * End-of-stage handoffs must (1) name the completed stage, (2) present next options, and (3) immediately load the chosen next skill when applicable — never silently skip the handoff
 
-* `/kw:lfg` is the only skill that chains stages without check-ins; other skills stay single-stage unless the user picks a handoff option
+* Handoff menus: Claude Code `AskUserQuestion` max 4 options — if more are visible, use a numbered list in chat instead of overloading the tool
+
+* `/kw:lfg` is the only skill that chains stages without check-ins; it invokes children with `mode:pipeline`. Other skills stay single-stage unless the user picks a handoff option; under `mode:pipeline` they return results to the caller and do not self-chain
 
 * Review agents live in `agents/review/`
 
diff --git a/plugins/compound-knowledge/CHANGELOG.md b/plugins/compound-knowledge/CHANGELOG.md
index d56d774..e382da5 100644
--- a/plugins/compound-knowledge/CHANGELOG.md
+++ b/plugins/compound-knowledge/CHANGELOG.md
@@ -17,7 +17,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 * `/kw:brainstorm` Step 7 reframed as an explicit "Brainstorm complete" handoff (never skip), aligned with CE's post-brainstorm progression
 * `/kw:plan`, `/kw:review`, `/kw:work`, and `/kw:compound` handoffs strengthened with stage-complete preambles and immediate skill load on selection
-* `/kw:confidence` re-anchors to the interrupted parent stage after the check
+* Handoff menus follow CE's AskUserQuestion cap: ≤4 options use the tool; more than 4 fall back to a numbered list (never call AskUserQuestion over the limit)
+* Pipeline Mode now keys off `mode:pipeline` (not `disable-model-invocation`); children return results to the caller instead of self-chaining
+* `/kw:compound` allows pipeline auto-save so `/kw:lfg` does not contradict "approval required"
+* LFG option labeled **Ship the rest**; existing `plans/*.md` paths skip re-planning; work end option renamed **Done for now**
+* `/kw:confidence` captures and resumes the interrupted parent stage
 * README / component counts updated for 7 skills
 
 ## [1.0.0] - 2026-03-22
diff --git a/plugins/compound-knowledge/README.md b/plugins/compound-knowledge/README.md
index c3178a9..037f744 100644
--- a/plugins/compound-knowledge/README.md
+++ b/plugins/compound-knowledge/README.md
@@ -17,7 +17,7 @@ Workflows for knowledge work that compounds over time. The knowledge work equiva
 
 Each cycle makes the next one faster. `/kw:plan` searches `docs/knowledge/` for past learnings saved by `/kw:compound`. Knowledge compounds.
 
-After `/kw:brainstorm`, the skill ends with an explicit handoff (create plan, or ship the rest with `/kw:lfg`) so you always know which stage you're in.
+After `/kw:brainstorm`, the skill ends with an explicit handoff (create plan, or **Ship the rest** with `/kw:lfg`) so you always know which stage you're in.
 
 ## Install