baro-ai 0.38.2 → 0.39.1

package/README.md

@@ -1,250 +1,150 @@
 # baro
 
-## Background Agent Runtime Orchestrator
-
-Give it a goal, it breaks it into stories, builds a dependency DAG, and runs them in parallel — each story gets its own AI agent.
+> Type a goal in your repo. Walk away. Come back to a pull request.
 
 ![npm downloads](https://img.shields.io/npm/dt/baro-ai) ![npm downloads weekly](https://img.shields.io/npm/dw/baro-ai) ![npm version](https://img.shields.io/npm/v/baro-ai)
 
-![baro screenshot](https://raw.githubusercontent.com/jigjoy-ai/baro/main/assets/screenshot.png)
+```bash
+npm install -g baro-ai
+```
 
-> 📖 **Deep dive:** [Getting the Maximum Out of My Claude Code Subscription](https://jigjoy.ai/blog/getting-the-maximum-out-of-claude-code) — the story of why baro exists, how it pairs with Mozaik, and what it looks like in practice.
+![baro TUI at the end of a real run — 33 of 33 stories complete on a NestJS service, 2.2× parallel speedup, 32 files modified, PR opened](https://raw.githubusercontent.com/jigjoy-ai/baro/main/assets/screenshot.png)
+
+<sub>baro TUI at the end of an [actual run](https://jigjoy.ai/blog/baro-808-nestjs-jest-tests) — one prompt → 33-story DAG → 32 files modified → PR opened. The summary panel shows wall time (33:23), parallel speedup (2.2×), token usage, and the PR URL.</sub>
+
+## Parallel coding agents, no central coordinator
+
+Most multi-agent setups have one orchestrator function in the middle that drives N agents. The orchestrator becomes the bottleneck the moment you push past a handful of concurrent agents — and adding a new behaviour means editing its control flow.
+
+baro doesn't have that shape. Every part of the run is an independent **participant** on a shared event bus ([Mozaik](https://github.com/jigjoy-ai/mozaik)). N parallel story agents are N independent subprocesses, each emitting and consuming typed events. There is no central `run()` to bottleneck on, and adding a new behaviour is a new participant — not an orchestrator rewrite.
+
+```mermaid
+flowchart LR
+    subgraph A["Typical multi-agent orchestrator"]
+        direction TB
+        C{{Coordinator}}
+        C --> A1[Agent 1]
+        C --> A2[Agent 2]
+        C --> A3[Agent N]
+    end
+    subgraph B["baro on Mozaik"]
+        direction TB
+        Bus[(shared event bus)]
+        P1[Conductor] -.-> Bus
+        P2[Story Agent 1] -.-> Bus
+        P3[Story Agent N] -.-> Bus
+        P4[Critic / Surgeon / ...] -.-> Bus
+    end
+```
 
-## What's new (0.22–0.23)
+That's the architectural lever. Everything else baro does — Architect, Planner, Critic, Surgeon, Librarian — is a participant on that bus. They don't call each other; they react to events.
 
-- **Opus as the default executor** — richer reasoning per story, still with routed Sonnet/Haiku available via `--model` or `.barorc`.
-- **Smaller-stories planner** — the planner now biases toward narrower, more independent stories that parallelize better on the DAG.
-- **Branch dedup** — reruns on the same goal reuse the existing `baro/<name>` branch instead of piling up duplicates.
-- **TUI: terminal-clear on tab switch** — cleaner transitions between story logs, DAG view, and stats.
-- **Audit log survives project resets** — JSONL event logs now live in `~/.baro/runs/` by default, so a wiped `node_modules` or a fresh clone doesn't lose history.
-- **Always-on audit + abnormal-exit banner** — every run is recorded, and the TUI surfaces an explicit banner when the orchestrator exits unexpectedly.
+## What a run looks like
 
-## Install
+```bash
+cd your-repo
+baro "Add JWT authentication with role-based access control"
+```
 
 ```
-npm install -g baro-ai
+→ Architect (45s)   — design decisions pinned for every story
+→ Planner   (38s)   — 7 stories in 3 levels
+→ Executing — 4 parallel Claude Code agents on baro/jwt-auth branch
+→ Critic    — per-turn acceptance evaluation, self-corrects on fail
+→ Finalizer — PR #142 opened ✓
 ```
 
-Requires [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) installed and authenticated.
+```mermaid
+flowchart LR
+    Goal([your goal]) --> A[Architect<br/><sub>~45s — emits<br/>DecisionDocument</sub>]
+    A --> P[Planner<br/><sub>~60s — emits DAG</sub>]
+    P --> S1[Story 1]
+    P --> S2[Story 2]
+    P --> S3[Story 3]
+    S1 --> S4[Story 4]
+    S2 --> S4
+    S3 --> S5[Story 5]
+    S4 --> F[Finalizer<br/><sub>opens PR</sub>]
+    S5 --> F
+    F --> PR([Pull Request])
+```
 
-## Usage
+Every story is one **Claude Code subprocess** (or one Mozaik-native OpenAI session) — auth inherits from your existing setup, no API key plumbing.
 
-```bash
-# Interactive - opens welcome screen
-baro
+## Recent real run
 
-# Direct - skip to planning
-baro "Add authentication with JWT and role-based access control"
+[**How baro generated 808 NestJS Jest tests autonomously in 71 minutes**](https://jigjoy.ai/blog/baro-808-nestjs-jest-tests) — one prompt, 33-story DAG, two sessions because of the Anthropic 3am usage cap, 64 test suites, 83.5% branch coverage, +13,606 lines of test code, zero phantom bug issues filed.
 
-# Use OpenAI for planning
-baro --planner openai "Add WebSocket support"
+## What each participant does
 
-# Limit parallelism to 3 concurrent stories
-baro --parallel 3 "Refactor database layer"
+| Participant | Role |
+|---|---|
+| **Architect** | One Opus call before planning — emits a `DecisionDocument` that pins every cross-cutting design decision (file paths, schemas, API shapes, library choices) so 30 parallel agents don't each invent their own |
+| **Planner** | Decomposes the goal into a story DAG, with the DecisionDocument already pinned |
+| **Conductor** | State machine that drives the run by reacting to bus events |
+| **StoryAgent** | One Claude Code subprocess per story; multi-turn loop until story completes |
+| **Critic** | Per-turn evaluator (Haiku). On fail verdict, injects corrective feedback as the agent's next turn |
+| **Sentry** | Flags overlapping Edit/Write tool calls across concurrent stories |
+| **Librarian** | Indexes one agent's Read/Grep findings so siblings don't redo the exploration |
+| **Surgeon** | On terminal failure, asks Opus for a richer replan (split / prereq / rewire) |
+| **Finalizer** | Runs build verification, opens the GitHub PR with stories table + stats |
 
-# Set story timeout to 5 minutes
-baro --timeout 300 "Add unit tests"
+Bus is open. CI deployers, Slack notifiers, ticket triggers — all new participants, no orchestrator changes. Architecture deep-dive: [I tested Claude Code's new /goal feature against my parallel agent setup](https://jigjoy.ai/blog/baro-vs-claude-code).
 
-# Force a specific model for all phases
-baro --model opus "Complex architecture redesign"
+## Try it
 
-# Disable model routing (use opus everywhere)
-baro --no-model-routing "Build entire app"
+```bash
+npm install -g baro-ai
 
-# Dry run - generate plan without executing
-baro --dry-run "Add REST API"
+# Full run (default — Architect + Planner + parallel Story Agents)
+baro "Migrate the hardcoded category data to a backend dictionary"
 
-# Resume interrupted execution (or execute a dry-run plan)
-baro --resume
+# Trivial goal — skip Architect + Critic + Surgeon, single story
+baro --quick "fix the typo on line 42 of README.md"
 
-# Specify working directory
-baro --cwd ~/projects/myapp "Add REST API"
-```
+# Route every phase through GPT-5.5 instead of Claude
+OPENAI_API_KEY=sk-... baro --llm openai "Refactor the database layer"
 
-## How it works
-
-1. **Plan** — Claude (Opus) explores your codebase and generates a dependency graph of user stories
-2. **Review** — You review the plan, refine with feedback, accept or quit
-3. **Execute** — Stories run in parallel on a feature branch, each with its own Claude agent (Opus by default in 0.23+; Sonnet/Haiku available via `--model` or `.barorc`)
-4. **Review Agent** — After each level, a review agent (Haiku) checks work against acceptance criteria and creates fix stories if needed
-5. **Finalize** — Runs build verification and creates a GitHub PR with full summary
-
-## Features
-
-- **Parallel execution** — independent stories run simultaneously, respecting dependency order
-- **DAG engine** — topological sort with level grouping, cycle detection
-- **Model routing** — Opus for planning and execution (0.23+ default), Haiku for review (configurable)
-- **Live TUI** — dashboard with story status, live agent logs, DAG view, stats
-- **Review agent** — automated code review between levels with build detection and auto-fix
-- **Plan refinement** — press `r` on review screen to give feedback and regenerate the plan
-- **Build detection** — auto-detects project type (Cargo, npm, Go, Python, Make) and runs builds during review
-- **Git coordination** — mutex-protected commits, auto-push with retry, pull --rebase, conflict detection
-- **Branch per run** — creates `baro/<name>` branch, keeps main clean, reuses existing branches on rerun (0.23+)
-- **Dry run** — `--dry-run` generates plan and saves to `prd.json` without executing, then `--resume` to run it
-- **Resume** — detects `prd.json` and resumes incomplete executions
-- **PR creation** — creates GitHub PR with stories table, stats, time saved, and review summary
-- **Configurable parallelism** — `--parallel N` to limit concurrent story execution
-- **Story timeout** — `--timeout SECONDS` kills stuck agents (default: 10 minutes, hard timeout disabled in 0.22+)
-- **Time saved** — shows parallel speedup vs sequential execution
-- **System notifications** — terminal bell + OS notification (macOS/Linux/Windows) when done
-- **Retry logic** — failed stories retry automatically (configurable per story)
-- **Interactive settings** — configure model, parallelism, timeout, context, and planner on the welcome screen with Tab/arrow keys
-- **Project config** — `.barorc` file in project root sets defaults (no CLI flags needed)
-- **Session lock** — prevents multiple baro instances from running in the same directory
-- **Audit log** — every bus event written to `~/.baro/runs/<run-id>.jsonl`
-
-## Config file
-
-Create a `.barorc` in your project root to set defaults:
-
-```json
-{
-  "model": "routed",
-  "parallel": 3,
-  "timeout": 600,
-  "skipContext": false,
-  "planner": "claude"
-}
-```
+# Limit parallelism (Anthropic plan tiers cap concurrency)
+baro --parallel 3 "Add unit tests for the auth module"
 
-All fields are optional. CLI flags override `.barorc`, and interactive changes on the welcome screen override both.
+# Dry-run first, execute later
+baro --dry-run "Add WebSocket support"
+baro --resume
 
-| Field | Values | Default |
-|-------|--------|---------|
-| `model` | `"routed"`, `"opus"`, `"sonnet"`, `"haiku"` | `"routed"` |
-| `parallel` | `0` (unlimited) or any number | `0` |
-| `timeout` | seconds per story | `600` |
-| `skipContext` | `true` / `false` | `false` |
-| `planner` | `"claude"`, `"openai"` | `"claude"` |
-| `dryRun` | `true` / `false` | `false` |
+# Self-diagnostic
+baro --doctor
+```
 
-## Options
+Full options + `.barorc` config + per-phase model overrides: [**docs.baro.rs**](https://docs.baro.rs).
 
-```
-baro [goal] [options]
-
-Arguments:
-  goal                         Project goal (opens welcome screen if omitted)
-
-Options:
-  --planner <name>             Planner: claude or openai (default: claude)
-  --model <name>               Override model for all phases: opus, sonnet, haiku
-  --no-model-routing           Use opus for everything (disables routing)
-  --parallel <N>               Max concurrent stories, 0 = unlimited (default: 0)
-  --timeout <seconds>          Story timeout in seconds (default: 600)
-  --dry-run                    Generate plan only, save to prd.json, do not execute
-  --resume                     Resume from existing prd.json (also runs dry-run plans)
-  --skip-context               Skip CLAUDE.md auto-generation
-  --cwd <path>                 Working directory (default: current)
-  --no-critic                  Disable live Critic (default: on). The Critic
-                               reviews each agent turn against acceptance
-                               criteria via `claude --model haiku` and injects
-                               corrective feedback when the turn doesn't pass.
-  --critic-model <name>        Model for the Critic (default: haiku)
-  --no-librarian               Disable cross-agent runtime memory (default: on)
-  --no-sentry                  Disable file-touch conflict detector (default: on)
-  --no-surgeon                 Disable Surgeon (default: on). The Surgeon
-                               observes terminal story failures and proposes
-                               replans (split / prereq / rewire) so failed
-                               work gets done in a different shape rather
-                               than dropped.
-  --no-surgeon-llm             Use deterministic Surgeon (skip-only) instead
-                               of the LLM-driven replanner. The LLM Surgeon
-                               is on by default; it costs an Opus call per
-                               terminal failure but produces richer replans.
-  --surgeon-model <name>       Model for the Surgeon LLM (default: opus)
-  -h, --help                   Print help
-```
+## How it compares
+
+| | Single Claude Code session | DIY `Promise.all` of subprocesses | baro |
+|---|---|---|---|
+| **Plans the work** | you | you | Planner agent |
+| **Pins design decisions** | implicit, drifts | n/a | Architect agent (`DecisionDocument`) |
+| **Parallel agents** | no — one session | yes, you coordinate | yes, on Mozaik bus |
+| **Mid-flight peer awareness** | n/a | implement yourself | Librarian broadcasts |
+| **Replan on failure** | manual | manual | Surgeon agent |
+| **Opens the PR** | manual | manual | Finalizer |
+| **Adding a new behaviour** | new prompt | refactor orchestrator | new bus participant |
 
-### Phase 2/3/4 observers (Mozaik bus)
-
-baro 0.19+ runs every story through a TypeScript Mozaik orchestrator.
-Stories on the same DAG level run truly in parallel and observers can
-react to one another's bus events:
-
-- **Librarian** (default ON) — when one agent reads a file or runs grep,
-  later agents in the run see the digest in their prompt and skip the
-  redundant exploration. Measurable token savings on multi-story runs.
-- **Sentry** (default ON) — flags overlapping Edit/Write tool calls
-  across concurrent stories.
-- **Critic** (default ON) — Haiku evaluator reviews each agent turn
-  against acceptance criteria; on a fail verdict, an inline corrective
-  message lands as the agent's next turn so it self-corrects before
-  commit. Disable with `--no-critic`.
-- **Surgeon** (default ON, with LLM) — when a story fails its retry
-  budget, the Surgeon asks Opus for a richer replan and emits a
-  ReplanItem the Conductor applies at the next level boundary. The LLM
-  is biased toward keeping the work done — it prefers splitting a too-
-  large story into smaller pieces, inserting a prerequisite, or
-  rewiring dependencies, over dropping outright. A run is reported as
-  successful only when every original story passes; if the Surgeon
-  drops a story without replacement, the run terminates with a clear
-  "did not complete the goal" verdict instead of a green tick. Disable
-  the LLM with `--no-surgeon-llm` to fall back to deterministic
-  skip-only behavior, or `--no-surgeon` to remove adaptive replans
-  entirely.
+For a deeper side-by-side on a real refactor, see [baro vs Claude Code `/goal`](https://jigjoy.ai/blog/baro-vs-claude-code).
 
 ## Requirements
 
-- [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) installed and authenticated
-- macOS (arm64/x64), Linux (x64/arm64), or Windows (x64)
-- **Node.js 20+** (orchestrator runtime)
+- [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) authenticated (for `--llm claude`, the default) **or** `OPENAI_API_KEY` set (for `--llm openai`)
+- Node.js 20+
+- macOS (arm64/x64), Linux (x64/arm64), Windows (x64)
 - `gh` CLI (optional, for automatic PR creation)
 
-> **Windows note:** Windows 10+ is required. For best TUI experience, use [Windows Terminal](https://aka.ms/terminal) or another modern terminal emulator.
-
-## Architecture
-
-Rust binary distributed via npm. TUI built with ratatui, async execution
-with tokio. Each `baro` invocation spawns the bundled TypeScript
-[Mozaik](https://github.com/jigjoy-ai/mozaik) orchestrator as a
-subprocess; the orchestrator owns story execution and emits typed
-events into a shared `AgenticEnvironment` bus. Each story is one
-`claude` CLI subprocess (auth inherits from your Claude CLI session —
-no API key needed).
-
-The orchestrator is itself a Mozaik agentic environment: there is no
-imperative `run()` method, no top-level `Promise.all` loop. The
-**Conductor** is a state machine that reacts to typed bus events
-(`RunStartRequest` → `LevelComputeRequest` → `StorySpawnRequest` →
-`StoryResult` → `LevelCompleted` → …). Spawning a story, evaluating a
-turn, and replanning the DAG are all reactions, not steps in a loop.
-
-Ten participants share that bus:
-
-| Participant     | Role                                                              |
-| --------------- | ----------------------------------------------------------------- |
-| `Conductor`     | Orchestration state machine — drives the run by reacting          |
-| `StoryFactory`  | Spawns Story Agents on each `StorySpawnRequest`                   |
-| `StoryAgent`    | Runs one story via Claude CLI, with retries and timeout           |
-| `Librarian`     | Cross-agent memory — indexes outputs of exploration tools         |
-| `Sentry`        | Flags overlapping file writes across concurrent stories           |
-| `Critic`        | Per-turn acceptance-criteria evaluator (default ON, `--no-critic` to disable) |
-| `Surgeon`       | Emits DAG replans when a story fails terminally (default ON, `--no-surgeon` to disable) |
-| `Operator`      | Bridges external user commands (TUI, web UI) into bus events      |
-| `Auditor`       | JSONL log of every event on the bus (written to `~/.baro/runs/`)  |
-| `Cartographer`  | Translates bus events into UI frames for the Rust TUI             |
-
-The bus is open. New participants — CI deployers, Slack notifiers,
-external ticket triggers — are subscribers and emitters with no changes
-to the orchestrator.
-
 ## Status & feedback
 
-baro is a work in progress. I'm actively adding things, testing ideas,
-and occasionally breaking them — if a run explodes, an [issue on
-GitHub](https://github.com/jigjoy-ai/baro/issues) with the run's audit
-log from `~/.baro/runs/` is the fastest way to get it fixed.
+baro is a work in progress. If a run explodes, the audit log at `~/.baro/runs/<run-id>.jsonl` is the fastest way to get it fixed — open an [issue](https://github.com/jigjoy-ai/baro/issues) with that file attached.
 
-If you like the idea and want to help shape where it goes, PRs are
-welcome, and you can DM me on Twitter
-[@lotus_sbc](https://twitter.com/lotus_sbc) with ideas, use cases, or
-bug reports.
+Ideas, use cases, bug reports — Discord: [**discord.gg/dvxY9J2kWX**](https://discord.gg/dvxY9J2kWX) · Twitter: [**@lotus_sbc**](https://twitter.com/lotus_sbc)
 
 ## License
 
-MIT
-
----
-
-Made by [Lotus](https://github.com/Lotus015) from [JigJoy](https://jigjoy.ai) team
+MIT — [JigJoy](https://jigjoy.ai/) team

package/dist/cli.mjs

@@ -8324,13 +8324,14 @@ var LevelCompletedItem = class extends BusEvent {
   }
 };
 var StorySpawnRequestItem = class extends BusEvent {
-  constructor(storyId, prompt, model, retries, timeoutSecs) {
+  constructor(storyId, prompt, model, retries, timeoutSecs, appendSystemPrompt) {
     super();
     this.storyId = storyId;
     this.prompt = prompt;
     this.model = model;
     this.retries = retries;
     this.timeoutSecs = timeoutSecs;
+    this.appendSystemPrompt = appendSystemPrompt;
   }
   type = "story_spawn_request";
   toJSON() {
@@ -8340,7 +8341,8 @@ var StorySpawnRequestItem = class extends BusEvent {
       promptLen: this.prompt.length,
       model: this.model,
       retries: this.retries,
-      timeoutSecs: this.timeoutSecs
+      timeoutSecs: this.timeoutSecs,
+      appendSystemPromptLen: this.appendSystemPrompt?.length ?? 0
     };
   }
 };
@@ -8864,6 +8866,9 @@ var ClaudeCliParticipant = class _ClaudeCliParticipant extends BaroParticipant {
     if (this.options.resumeSessionId) {
       args.push("--resume", this.options.resumeSessionId);
     }
+    if (this.options.appendSystemPrompt && this.options.appendSystemPrompt.length > 0) {
+      args.push("--append-system-prompt", this.options.appendSystemPrompt);
+    }
     if (this.options.extraArgs && this.options.extraArgs.length > 0) {
       args.push(...this.options.extraArgs);
     }
@@ -9122,7 +9127,8 @@ var StoryAgent = class extends BaroParticipant {
     this.transition("running", `attempt ${attempt}`);
     const claude = new ClaudeCliParticipant(this.spec.id, {
       cwd: this.spec.cwd,
-      model: this.spec.model
+      model: this.spec.model,
+      appendSystemPrompt: this.spec.appendSystemPrompt
     });
     this.currentClaude = claude;
     claude.join(this.envRef);
@@ -9482,7 +9488,9 @@ var Conductor = class extends BaroParticipant {
   }
   async requestStorySpawn(story) {
     const model = this.opts.overrideModel ?? story.model ?? this.opts.defaultModel;
-    let prompt = this.resolvePrompt(story);
+    const resolved = this.resolvePrompt(story);
+    let prompt = resolved.userPrompt;
+    const appendSystemPrompt = resolved.appendSystemPrompt;
     if (this.opts.onBeforeStoryLaunch) {
       try {
         const extra = await this.opts.onBeforeStoryLaunch(story.id, story);
@@ -9507,7 +9515,8 @@ ${prompt}`;
         prompt,
         model,
         story.retries,
-        this.opts.timeoutSecs
+        this.opts.timeoutSecs,
+        appendSystemPrompt
       )
     );
   }
@@ -9617,24 +9626,26 @@ ${prompt}`;
       prompt = buildDefaultStoryPrompt(story);
     }
     const doc = this.prd?.decisionDocument;
-    if (doc && doc.trim().length > 0) {
-      const header = [
-        "## Design spec (authoritative \u2014 already decided)",
-        "",
-        "The Architect made these decisions before any story started.",
-        "Treat them as fixed: use these exact file paths, names,",
-        "schemas, API shapes, and dependency choices. Do NOT",
-        "improvise alternatives \u2014 your siblings are working from",
-        "the same spec and divergence breaks the build.",
-        "",
-        doc.trim(),
-        "",
-        "---",
-        ""
-      ].join("\n");
-      prompt = header + prompt;
-    }
-    return prompt;
+    if (!doc || doc.trim().length === 0) {
+      return { userPrompt: prompt };
+    }
+    const trimmedDoc = doc.trim();
+    const headerLines = [
+      "## Design spec (authoritative \u2014 already decided)",
+      "",
+      "The Architect made these decisions before any story started.",
+      "Treat them as fixed: use these exact file paths, names,",
+      "schemas, API shapes, and dependency choices. Do NOT",
+      "improvise alternatives \u2014 your siblings are working from",
+      "the same spec and divergence breaks the build.",
+      ""
+    ];
+    if (this.opts.shareArchitectCache) {
+      const appendSystemPrompt = [...headerLines, trimmedDoc].join("\n");
+      return { userPrompt: prompt, appendSystemPrompt };
+    }
+    const header = [...headerLines, trimmedDoc, "", "---", ""].join("\n");
+    return { userPrompt: header + prompt };
   }
   emit(event) {
     this.envRef?.deliverBusEvent(this, event);
@@ -11684,7 +11695,8 @@ var StoryFactory = class extends BaroParticipant {
       cwd: this.opts.cwd,
       model: claudeModel,
       retries: req.retries,
-      timeoutSecs: req.timeoutSecs
+      timeoutSecs: req.timeoutSecs,
+      appendSystemPrompt: req.appendSystemPrompt
     });
     agent.join(this.envRef);
     this.active.set(req.storyId, agent);
@@ -12114,6 +12126,7 @@ async function orchestrate(config) {
     overrideModel: config.overrideModel ?? void 0,
     defaultModel: config.defaultModel ?? "opus",
     intraLevelDelaySecs: config.intraLevelDelaySecs,
+    shareArchitectCache: config.shareArchitectCache ?? false,
     onRunStart: useGit ? async (prd) => {
       baseSha = await getHeadSha(config.cwd);
       if (prd.branchName) {
@@ -12401,6 +12414,7 @@ function parseArgs(argv) {
     withSurgeon: false,
     surgeonUseLlm: false,
     llm: "claude",
+    shareArchitectCache: false,
     help: false
   };
   for (let i = 0; i < argv.length; i++) {
@@ -12474,6 +12488,9 @@ function parseArgs(argv) {
         args.llm = v;
         break;
       }
+      case "--share-architect-cache":
+        args.shareArchitectCache = true;
+        break;
       default:
         process.stderr.write(`[cli] unknown flag: ${a}
 `);
@@ -12553,7 +12570,8 @@ async function main() {
     surgeonModel: args.surgeonModel,
     intraLevelDelaySecs: args.intraLevelDelaySecs,
     llm: args.llm,
-    storyModel: args.storyModel
+    storyModel: args.storyModel,
+    shareArchitectCache: args.shareArchitectCache
   };
   if (args.llm === "openai" && !process.env.OPENAI_API_KEY) {
     process.stderr.write(