fanout-cli 0.9.1 → 0.9.3

package/{plugin/.claude-plugin → .claude-plugin}/plugin.json

@@ -1,19 +1,12 @@
 {
   "name": "fanout",
   "description": "Lead a crew of the coding-agent CLIs you already pay for: plan, fan out into isolated git worktrees, watch, and review before anything merges.",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "author": {
     "name": "elberacasa"
   },
   "homepage": "https://github.com/elberacasa/fanout",
   "repository": "https://github.com/elberacasa/fanout",
   "license": "MIT",
-  "keywords": [
-    "agents",
-    "orchestration",
-    "codex",
-    "grok",
-    "worktrees",
-    "local-first"
-  ]
+  "keywords": ["agents", "orchestration", "codex", "grok", "worktrees", "local-first"]
 }

package/README.md

@@ -1,48 +1,44 @@
-# fanout-cli
+# The Fanout plugin for Claude Code
 
-Let Claude Code lead the other coding-agent CLIs you already pay for.
+Claude Code becomes the lead: it plans a mission, fans it out to the other agent CLIs on your machine, watches them
+work in isolated git worktrees, and reviews every diff. Nothing merges without you.
 
-Fanout is a local daemon and a Claude Code plugin. Claude plans the work; the other agents you have installed and
-signed in — Codex, and Claude itself when you opt in — do pieces of it in parallel, each in its own git worktree.
-Nothing merges until it has been reviewed by someone who did not write it, passed your project's own checks, and
-been approved by you.
+## What you get
 
-## See it without an account
+| | |
+|---|---|
+| `/fanout <goal>` | Plan a mission, check it against the safety gate, launch it, and watch it |
+| `/fanout:crew` | Which CLIs are installed, signed in, and ready |
+| `/fanout:watch [mission]` | Subscribe to the live feed and review each run as it finishes |
+| The `fanout` skill | The lead's judgment: when to fan out, how to write a prompt an agent can follow, how to review what comes back |
+| Hooks | The crew at the start of a session; a warning if runs are still going when you stop |
+| Seven MCP tools | `seats`, `repo_overview`, `plan_check`, `launch`, `mission_status`, `run_diff`, `cancel_mission` |
 
-```sh
-npx fanout-cli demo
-```
+## Installing
 
-Three simulated agents run a real mission on a throwaway repository, in real worktrees, through the real gate. No
-sign-in, no API key, no network. It prints a local URL — open it to watch.
+The plugin runs `fanout mcp`, so the `fanout` command must be on your `PATH`.
 
-## Use it for real
+**From a clone**, while the package is not yet published:
 
 ```sh
-npm install -g fanout-cli
-fanout seat        # what is installed on this machine, and what is signed in
-fanout demo        # the offline walkthrough
-fanout help        # everything else
+git clone https://github.com/elberacasa/fanout.git && cd fanout
+corepack enable && pnpm install
+pnpm --filter fanout-cli link --global   # puts `fanout` on your PATH
+claude --plugin-dir "$PWD/plugin"          # try it in one session
 ```
 
-Then add the plugin, which is what Claude Code drives:
+Check it before you rely on it:
 
+```sh
+fanout status        # your crew
+claude plugin validate plugin
 ```
-/plugin marketplace add elberacasa/fanout
-/plugin install fanout@fanout
-```
-
-That gives you `/fanout <goal>` inside your session.
 
 ## What it will not do
 
-- **It never touches your credentials.** Each agent runs through its vendor's own documented non-interactive mode,
-  on your machine, under your account. Fanout does not read, copy, store, proxy or reuse a session token, and does
-  not work around anyone's rate limits.
-- **It never merges unreviewed work.** Review, your project's checks, and your approval must all have judged the
-  same revision of the same diff. A bug fix additionally needs a test proven to fail on the old code.
-- **It never commits on your branch without you.** Agents work in isolated worktrees and cannot reach your files,
-  your secrets, or anything git ignores.
-- **It sends nothing anywhere.** Your code, your prompts and the ledger stay on your machine. There is no telemetry.
-
-Requires Node 22.18 or newer. MIT licensed.
+- **It will not merge.** It reads a run's diff from the workspace and hands you the decision. The merge gate, with
+  review, your project's checks and proof that a fix fails on the old code, is the next milestone.
+- **It will not work around a usage limit.** A seat that is out of quota is out; the lead says so and uses another.
+- **It will not hand an agent your secrets.** Workspaces exclude ignored and deny-listed files, and a run gets an
+  allowlisted environment only — never your shell's.
+- **It sends nothing anywhere.** The daemon listens on `127.0.0.1` with a token only you can read.

package/{plugin/bin → bin}/fanout

@@ -18,22 +18,26 @@ import { fileURLToPath } from "node:url";
  *
  * There are two real layouts and this script is the one place that knows the difference:
  *
- *   published   <package>/plugin/bin/fanout  →  <package>/dist/cli.js
- *   checkout    <repo>/plugin/bin/fanout     →  <repo>/packages/cli/src/cli.ts
+ *   published   <package>/bin/fanout      →  <package>/dist/cli.js
+ *   checkout    <repo>/plugin/bin/fanout  →  <repo>/packages/cli/src/cli.ts
+ *
+ * The published path lost a level when the plugin was flattened into the package root, which it had to be:
+ * Claude Code treats the installed package's own root as the plugin root, and a manifest one directory down is
+ * a plugin that installs, reports itself enabled, and loads nothing.
  *
  * Ordered with the published layout first: that is the one a stranger has, and the one nobody here would notice
  * was broken.
  */
 
 const here = new URL(".", import.meta.url);
-const candidates = ["../../dist/cli.js", "../../packages/cli/src/cli.ts"];
+const candidates = ["../dist/cli.js", "../../packages/cli/src/cli.ts"];
 
 const cli = candidates.map((path) => fileURLToPath(new URL(path, here))).find((path) => existsSync(path));
 
 if (cli === undefined) {
   process.stderr.write(
     "fanout: this plugin cannot find the Fanout CLI beside it.\n" +
-      "  Looked for dist/cli.js and packages/cli/src/cli.ts next to the plugin directory.\n" +
+      "  Looked for ../dist/cli.js and ../../packages/cli/src/cli.ts from this script.\n" +
       "  If you installed from npm, reinstall fanout-cli; if this is a checkout, run pnpm install first.\n",
   );
   process.exit(69);

package/{plugin/commands → commands}/fanout.md

@@ -7,24 +7,30 @@ The user wants this done by the crew: **$ARGUMENTS**
 
 You are the lead. Work in this order, and do not skip the parts that keep it safe.
 
-1. **Look before planning.** Call `repo_overview` and `seats`. If no seat is ready, say so and stop: there is no
+1. **Say back what you heard, before anything else.** Restate the goal in one line — `Planning: <goal>` — in the
+   words you received it in. A prompt pasted into a terminal can arrive with characters missing, silently: a real
+   paste turned "fails on the old code" into "fails on the olcode" and nothing reported it. A goal that lost a
+   word still produces a confident plan, and every step after that looks reasonable, so this line is the only
+   place the input itself is ever visible. If it reads as truncated, contradictory or half a sentence, ask
+   instead of guessing.
+2. **Look before planning.** Call `repo_overview` and `seats`. If no seat is ready, say so and stop: there is no
    crew to lead.
-2. **Split the work honestly.** One line per piece that can stand alone, each with:
+3. **Split the work honestly.** One line per piece that can stand alone, each with:
    - a **write scope** narrow enough that no two lines that run at once can touch the same file;
    - a **prompt** that names the exact files, the expected behaviour with an example, the project's check commands,
      and "do not commit";
    - a **seat**: give the risky or subtle piece to the strongest seat, the mechanical piece to the cheapest, and
      read-only work to an auditor. Claude is opt-in; prefer the other subscriptions.
    Dependent work goes in `dependsOn` rather than in one big line.
-3. **Check before launching.** Call `plan_check`. Fix what it blocks; do not argue with it. Show the user the plan
+4. **Check before launching.** Call `plan_check`. Fix what it blocks; do not argue with it. Show the user the plan
    as a short list (line, seat, scope) and the dry run if they ask.
-4. **Launch** with `launch`, then tell the user the mission id and what each line is doing.
-5. **Watch** with `mission_status`. While runs are going, do not start unrelated work in this session: you are the
+5. **Launch** with `launch`, then tell the user the mission id and what each line is doing.
+6. **Watch** with `mission_status`. While runs are going, do not start unrelated work in this session: you are the
    lead, and reviewing is your job.
-6. **Review each finished run** with `run_diff`. Read the risky lines yourself. Anything written outside its scope
+7. **Review each finished run** with `run_diff`. Read the risky lines yourself. Anything written outside its scope
    is the first thing you look at. Then tell the user, per run: what it changed, what you would keep, what you would
    not, and what you could not verify.
-7. **Merging is the user's call, and it is not automatic.** Apply a diff yourself only when they say so, run the
+8. **Merging is the user's call, and it is not automatic.** Apply a diff yourself only when they say so, run the
    project's real checks afterwards, and never present an agent's "tests pass" as your own verification.
 
 If something fails, say which line, why, and what you propose — never "it didn't work".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fanout-cli",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Let Claude Code lead the other coding-agent CLIs you already pay for.",
   "license": "MIT",
   "type": "module",
@@ -14,31 +14,29 @@
   },
   "homepage": "https://github.com/elberacasa/fanout#readme",
   "bin": {
-    "fanout": "./src/cli.ts"
+    "fanout": "./dist/cli.js"
   },
   "exports": {
-    ".": "./src/main.ts"
+    ".": {
+      "default": "./dist/cli.js"
+    }
   },
   "files": [
+    ".claude-plugin",
+    ".mcp.json",
+    "bin",
+    "commands",
     "dist",
-    "plugin",
+    "hooks",
+    "skills",
     "README.md",
     "LICENSE"
   ],
-  "publishConfig": {
-    "exports": {
-      ".": {
-        "default": "./dist/cli.js"
-      }
-    },
-    "bin": {
-      "fanout": "./dist/cli.js"
-    }
-  },
   "scripts": {
     "typecheck": "tsc -p tsconfig.json",
     "build": "node ../../scripts/bundle-cli.mjs",
-    "prepack": "node ../../scripts/bundle-cli.mjs"
+    "prepack": "node ../../scripts/bundle-cli.mjs",
+    "prepublishOnly": "node ../../scripts/check-publish.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",

package/plugin/README.md

@@ -1,44 +0,0 @@
-# The Fanout plugin for Claude Code
-
-Claude Code becomes the lead: it plans a mission, fans it out to the other agent CLIs on your machine, watches them
-work in isolated git worktrees, and reviews every diff. Nothing merges without you.
-
-## What you get
-
-| | |
-|---|---|
-| `/fanout <goal>` | Plan a mission, check it against the safety gate, launch it, and watch it |
-| `/fanout:crew` | Which CLIs are installed, signed in, and ready |
-| `/fanout:watch [mission]` | Subscribe to the live feed and review each run as it finishes |
-| The `fanout` skill | The lead's judgment: when to fan out, how to write a prompt an agent can follow, how to review what comes back |
-| Hooks | The crew at the start of a session; a warning if runs are still going when you stop |
-| Seven MCP tools | `seats`, `repo_overview`, `plan_check`, `launch`, `mission_status`, `run_diff`, `cancel_mission` |
-
-## Installing
-
-The plugin runs `fanout mcp`, so the `fanout` command must be on your `PATH`.
-
-**From a clone**, while the package is not yet published:
-
-```sh
-git clone https://github.com/elberacasa/fanout.git && cd fanout
-corepack enable && pnpm install
-pnpm --filter fanout-cli link --global   # puts `fanout` on your PATH
-claude --plugin-dir "$PWD/plugin"          # try it in one session
-```
-
-Check it before you rely on it:
-
-```sh
-fanout status        # your crew
-claude plugin validate plugin
-```
-
-## What it will not do
-
-- **It will not merge.** It reads a run's diff from the workspace and hands you the decision. The merge gate, with
-  review, your project's checks and proof that a fix fails on the old code, is the next milestone.
-- **It will not work around a usage limit.** A seat that is out of quota is out; the lead says so and uses another.
-- **It will not hand an agent your secrets.** Workspaces exclude ignored and deny-listed files, and a run gets an
-  allowlisted environment only — never your shell's.
-- **It sends nothing anywhere.** The daemon listens on `127.0.0.1` with a token only you can read.

package/src/cli.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-// First, and it has to stay first: it silences a warning that fires while the imports below are evaluating.
-import "./quiet.ts";
-import { main } from "./main.ts";
-
-/* The thin edge of the CLI: everything testable lives in main.ts, which takes its output as an argument. */
-
-const code = await main(process.argv.slice(2), {
-  out: (text) => process.stdout.write(text),
-  err: (text) => process.stderr.write(text),
-});
-process.exitCode = code;