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/README.md b/README.md
index e1b87a0..cb1473f 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** 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/.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"
   ]
 }
diff --git a/plugins/compound-knowledge/AGENTS.md b/plugins/compound-knowledge/AGENTS.md
index f2d2d5d..720f9e5 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,12 @@ 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
+
+* 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/`
 
 * Research agents live in `agents/research/`
@@ -58,4 +65,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..e382da5 100644
--- a/plugins/compound-knowledge/CHANGELOG.md
+++ b/plugins/compound-knowledge/CHANGELOG.md
@@ -4,6 +4,26 @@ 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
+* 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
 
 ### Added
@@ -52,4 +72,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..037f744 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-brainstorm/SKILL.md b/plugins/compound-knowledge/skills/kw-brainstorm/SKILL.md
index a1bab31..d95bed4 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,53 @@ 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
 
-Use AskUserQuestion:
+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.
 
-**Question:** "Brainstorm captured. What next?"
+Preamble (always show first):
 
-**Options:**
+```
+**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?
+```
 
-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
+**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 "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 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.
@@ -204,10 +238,10 @@ If "Save" or "Run /kw:plan" is selected: ALWAYS write the brainstorm to `plans/b
 
 ## 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
 - 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 (origin path, themes, open questions)
diff --git a/plugins/compound-knowledge/skills/kw-compound/SKILL.md b/plugins/compound-knowledge/skills/kw-compound/SKILL.md
index 2b8df14..ccdfd54 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
@@ -58,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
 
@@ -129,32 +134,45 @@ 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:
+**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:plan`** — Start a new planning cycle (the 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
+
+* **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.
 
@@ -166,10 +184,10 @@ Use AskUserQuestion:
 
 ## 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 40ff830..013fe09 100644
--- a/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
+++ b/plugins/compound-knowledge/skills/kw-confidence/SKILL.md
@@ -7,6 +7,12 @@ 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 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
 
 * Before committing to a plan or starting execution
@@ -148,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
new file mode 100644
index 0000000..07abdb3
--- /dev/null
+++ b/plugins/compound-knowledge/skills/kw-lfg/SKILL.md
@@ -0,0 +1,134 @@
+---
+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 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>
+
+# 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 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 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` in this order:
+
+| Form | Meaning |
+|------|---------|
+| `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 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
+
+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, 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)
+
+LFG alone advances stages after each child returns.
+
+---
+
+## Step 1: Plan
+
+**Skip** if a plan path was resolved from inputs (`plan:` or existing non-brainstorm `plans/*.md`).
+
+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` 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 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` 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` 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
+
+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]
+```
+
+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 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`
+
+| | 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 |
+| Runtime carrier | `mode:pipeline` / return-to-caller | `mode:pipeline` on each child invoke |
diff --git a/plugins/compound-knowledge/skills/kw-plan/SKILL.md b/plugins/compound-knowledge/skills/kw-plan/SKILL.md
index dbc96c0..c946e82 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
@@ -94,7 +101,7 @@ Before writing anything, present a context brief:
 **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."
+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
 
@@ -294,19 +301,39 @@ 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
 
-Use AskUserQuestion:
+```
+**Plan complete.**
 
-**Question:** "Plan written to `plans/{filename}`. What next?"
+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`** — 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. **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
 
@@ -322,10 +349,10 @@ Use AskUserQuestion:
 
 ## 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-review/SKILL.md b/plugins/compound-knowledge/skills/kw-review/SKILL.md
index 50a164c..85f0944 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,19 +101,38 @@ 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
 
-Use AskUserQuestion:
+```
+**Review complete.**
 
-**Question:** "Review complete. \[N] findings (\[P1 count] critical, \[P2 count] important). What next?"
+Findings: [N] ([P1 count] critical, [P2 count] important, [P3 count] nice-to-have)
+
+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. **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
+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
 
@@ -123,10 +148,10 @@ Use AskUserQuestion:
 
 ## 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 6ea231e..48b9e69 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
@@ -43,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                               |
@@ -95,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:**
@@ -171,19 +179,38 @@ 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
+
+What would you like to do next?
+```
 
-Use AskUserQuestion:
+**Handoff rendering (required):** Claude Code `AskUserQuestion` supports at most **4** options.
 
-**Question:** "Execution complete. \[N] deliverables produced. What next?"
+* 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`** — Quality check the outputs
-2. **Run `/kw:compound`** — Save learnings from this session
-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
+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. **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
 
@@ -199,10 +226,10 @@ Use AskUserQuestion:
 
 ## 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