Strengthen stage handoffs and add /kw:lfg (CE-style loop runner)

.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"
     }
   ]

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 |
 

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"
   ]
 }

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.

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
+* README with install and usage instructions

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 |
 

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)

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