@wrongstack/core 0.9.4 → 0.9.19

package/dist/defaults/index.js

@@ -319,9 +319,11 @@ function isEmptyMessage(msg) {
 var DefaultSessionStore = class {
   dir;
   events;
+  secretScrubber;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
+    this.secretScrubber = opts.secretScrubber;
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
@@ -346,7 +348,11 @@ var DefaultSessionStore = class {
       );
     }
     try {
-      return new FileSessionWriter(id, handle, startedAt, meta, this.events, { dir: shardDir, filePath: file });
+      return new FileSessionWriter(id, handle, startedAt, meta, this.events, {
+        dir: shardDir,
+        filePath: file,
+        secretScrubber: this.secretScrubber
+      });
     } catch (err) {
       await handle.close().catch(() => {
       });
@@ -376,7 +382,7 @@ var DefaultSessionStore = class {
           provider: data.metadata.provider
         },
         this.events,
-        { resumed: true, dir: this.dir, filePath: file }
+        { resumed: true, dir: this.dir, filePath: file, secretScrubber: this.secretScrubber }
       );
       return { writer, data };
     } catch (err) {
@@ -582,6 +588,7 @@ var FileSessionWriter = class {
     this.resumed = opts.resumed ?? false;
     this.manifestFile = opts.dir ? path15.join(opts.dir, `${id}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
+    this.secretScrubber = opts.secretScrubber;
     this.summary = {
       id,
       title: "(empty session)",
@@ -610,6 +617,29 @@ var FileSessionWriter = class {
   resumed;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
+  secretScrubber;
+  /**
+   * Scrub secrets out of conversation-turn events before they are observed
+   * for the summary, written to the JSONL log, or surfaced on resume. Only
+   * `user_input` / `llm_response` carry free-form user/model text; other event
+   * types either have no secret-bearing content or are already scrubbed
+   * upstream (tool results). Returns the event unchanged when no scrubber is
+   * configured.
+   */
+  scrubEvent(event) {
+    const s = this.secretScrubber;
+    if (!s) return event;
+    if (event.type === "user_input") {
+      return {
+        ...event,
+        content: typeof event.content === "string" ? s.scrub(event.content) : s.scrubObject(event.content)
+      };
+    }
+    if (event.type === "llm_response") {
+      return { ...event, content: s.scrubObject(event.content) };
+    }
+    return event;
+  }
   promptIndex = 0;
   pendingFileSnapshots = [];
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
@@ -642,9 +672,10 @@ var FileSessionWriter = class {
       this.initDone = true;
       await this.writeSessionStartLazy();
     }
-    this.observeForSummary(event);
+    const scrubbed = this.scrubEvent(event);
+    this.observeForSummary(scrubbed);
     try {
-      await this.handle.appendFile(`${JSON.stringify(event)}
+      await this.handle.appendFile(`${JSON.stringify(scrubbed)}
 `, "utf8");
     } catch (err) {
       this.appendFailCount++;
@@ -1266,6 +1297,9 @@ function isSecretField(name) {
   return SECRET_KEY_PATTERN.test(lc);
 }
 
+// src/storage/config-loader.ts
+init_atomic_write();
+
 // src/types/context-window.ts
 var DEFAULT_CONTEXT_WINDOW_MODE_ID = "balanced";
 var CONTEXT_WINDOW_MODES = Object.freeze([
@@ -1510,6 +1544,40 @@ var DefaultConfigLoader = class {
     }
     return Object.freeze(cfg);
   }
+  /**
+   * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
+   * by the vault (if provided). The file is isolated from the main config
+   * hierarchy to prevent accidental commits.
+   */
+  async persistSyncConfig(cfg) {
+    let toWrite = { ...cfg };
+    if (this.vault && toWrite.githubToken && !toWrite.githubToken.startsWith("enc:")) {
+      toWrite = { ...toWrite, githubToken: this.vault.encrypt(toWrite.githubToken) };
+    }
+    await atomicWrite(this.paths.syncConfig, JSON.stringify(toWrite, null, 2), { mode: 384 });
+  }
+  /**
+   * Read ~/.wrongstack/sync.json (encrypted GitHub token storage) and decrypt
+   * the token if a vault is available. Returns null if the file doesn't exist.
+   * This is separate from main config loading because sync.json is intentionally
+   * isolated — it should never be part of project-local or env-driven config.
+   */
+  async loadSyncConfig() {
+    try {
+      const raw = await fsp.readFile(this.paths.syncConfig, "utf8");
+      const parsed = safeParse(raw);
+      if (!parsed.ok || !parsed.value) return null;
+      if (this.vault) {
+        const decrypted = decryptConfigSecrets({ sync: parsed.value }, this.vault);
+        return decrypted.sync ?? null;
+      }
+      return parsed.value;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      console.warn("[config] Failed to load sync config:", err);
+      return null;
+    }
+  }
   async readJson(file) {
     let raw;
     try {
@@ -3126,7 +3194,11 @@ var DefaultPermissionPolicy = class {
       return { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" };
     }
     if (this.sessionAllowed.has(subjectKey)) {
-      return { permission: "auto", source: "trust", reason: "session soft allow (user pressed yes)" };
+      return {
+        permission: "auto",
+        source: "trust",
+        reason: "session soft allow (user pressed yes)"
+      };
     }
     if (entry?.deny && subject && matchAny(entry.deny, subject)) {
       return { permission: "deny", source: "deny", reason: "matched deny pattern" };
@@ -3146,7 +3218,11 @@ var DefaultPermissionPolicy = class {
           const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
           if (decision === "always") {
             await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
-            return { permission: "auto", source: "user", reason: "destructive yolo always-allowed" };
+            return {
+              permission: "auto",
+              source: "user",
+              reason: "destructive yolo always-allowed"
+            };
           }
           if (decision === "deny") {
             await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
@@ -3154,13 +3230,22 @@ var DefaultPermissionPolicy = class {
           }
           return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
         }
-        return { permission: "confirm", source: "yolo_destructive", riskTier: "destructive", reason: "destructive tool needs explicit approval even in yolo mode" };
+        return {
+          permission: "confirm",
+          source: "yolo_destructive",
+          riskTier: "destructive",
+          reason: "destructive tool needs explicit approval even in yolo mode"
+        };
       }
       return { permission: "auto", source: "yolo" };
     }
     if (tool.name === "write" && subject) {
       if (ctx.hasRead(subject)) {
-        return { permission: "auto", source: "context", reason: "file already read in this session" };
+        return {
+          permission: "auto",
+          source: "context",
+          reason: "file already read in this session"
+        };
       }
     }
     if (tool.permission === "auto" && !tool.mutating) {
@@ -3268,6 +3353,10 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
     // arbitrary shell — use exec for constrained shell
     "write",
     // arbitrary file write
+    "edit",
+    // arbitrary in-project file modification (equivalent to write)
+    "replace",
+    // arbitrary multi-file find/replace (equivalent to write)
     "scaffold",
     // arbitrary file generation outside project root
     "patch",
@@ -3277,12 +3366,22 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
     "exec"
     // restricted shell but with arbitrary command args
   ]);
+  /**
+   * Tools from MCP servers (`mcp__<server>__<tool>`) are external code of
+   * unknown capability — they may wrap a shell or filesystem. They are
+   * fail-closed here: not auto-approved for subagents by default, so the
+   * leader must allow them explicitly per-spawn.
+   */
+  static isMcpTool(name) {
+    return name.startsWith("mcp__");
+  }
   async evaluate(tool) {
-    if (tool.permission === "deny" || _AutoApprovePermissionPolicy.DENY.has(tool.name)) {
+    const blocked = _AutoApprovePermissionPolicy.DENY.has(tool.name) || _AutoApprovePermissionPolicy.isMcpTool(tool.name);
+    if (tool.permission === "deny" || blocked) {
       return {
         permission: "deny",
         source: "subagent_guard",
-        reason: _AutoApprovePermissionPolicy.DENY.has(tool.name) ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+        reason: blocked ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
       };
     }
     return { permission: "auto", source: "yolo" };
@@ -3697,6 +3796,90 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  let result = s;
+  const trimmed = result.trim();
+  if (!trimmed.startsWith("{")) return s;
+  for (let pass = 0; pass < 3; pass++) {
+    let braceDepth = 0;
+    let inString2 = false;
+    let escaped2 = false;
+    let foundClose = false;
+    for (const ch of result) {
+      if (escaped2) {
+        escaped2 = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped2 = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString2 = !inString2;
+        continue;
+      }
+      if (inString2) continue;
+      if (ch === "{") {
+        braceDepth++;
+        foundClose = false;
+      } else if (ch === "}") {
+        braceDepth--;
+        if (braceDepth === 0) foundClose = true;
+      }
+    }
+    if (foundClose || braceDepth <= 0) break;
+    result += "}".repeat(braceDepth);
+  }
+  if (tryParse(result).ok) return result;
+  let inString = false;
+  let escaped = false;
+  for (let i = result.length - 1; i >= 0; i--) {
+    const ch = result[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      let nextNonWs;
+      for (let j = i + 1; j < result.length; j++) {
+        const nc = result[j];
+        if (nc === " " || nc === "	" || nc === "\n" || nc === "\r") continue;
+        nextNonWs = result[j];
+        break;
+      }
+      if (nextNonWs === ":") {
+        continue;
+      } else {
+        inString = !inString;
+        continue;
+      }
+    }
+  }
+  if (inString) {
+    result = result.trimEnd();
+    if (result.endsWith("\\")) result = result.slice(0, -1);
+    let depth = 0;
+    for (const ch of result) {
+      if (ch === "{") depth++;
+      else if (ch === "}") depth = Math.max(0, depth - 1);
+    }
+    result += '"' + "}".repeat(Math.max(1, depth));
+  }
+  return result;
+}
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+
 // src/core/streaming-response-builder.ts
 function buildResponse(state) {
   const content = [];
@@ -3794,7 +3977,12 @@ function safeJsonOrRaw(s) {
   try {
     return JSON.parse(s);
   } catch {
-    return { _raw: s };
+    const repaired = completePartialObject(s);
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return { _raw: repaired };
+    }
   }
 }
 function handleToolUseStop(state, ev) {
@@ -9069,11 +9257,46 @@ Working rules:
 - When in doubt, flag as medium rather than ignoring potential issues`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
+var CRITIC_AGENT = {
+  id: "critic",
+  name: "Critic",
+  role: "critic",
+  prompt: `You are the Critic agent. Your job is to evaluate code quality,
+architectural decisions, and proposed changes against project conventions,
+engineering standards, and known quality gates. You do not write code \u2014
+you judge it.
+
+Scope:
+- Evaluate bug severity and fix quality from Bug Hunter reports
+- Score refactoring plans from Refactor Planner (risk, completeness, trade-offs)
+- Flag gaps in test coverage, error handling, and edge case coverage
+- Assess whether a proposed change aligns with existing project patterns
+- Detect over-engineering or under-engineering relative to the problem scope
+
+Input format you accept:
+{ "task": "evaluate | score | review", "subject": "bug_report | refactor_plan | diff", "focus": "correctness | maintainability | risk | all" }
+
+Output: Markdown critic report:
+- ## Overall Score (0-10 with rationale)
+- ## Strengths (what's solid)
+- ## Weaknesses (what needs work)
+- ## Specific Concerns (with file:line when applicable)
+- ## Verdict: **Approve / Needs Revision / Reject**
+
+Working rules:
+- Be specific \u2014 "looks fine" is not a review. Cite concrete evidence.
+- When scoring, explain the delta from a perfect score.
+- If you have no basis to evaluate a concern, say so rather than speculating.
+- Prioritise correctness over style; correctness issues block approval.
+- Score thresholds: \u22657 = Approve, 4-6 = Needs Revision, <4 = Reject`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
+  "critic": CRITIC_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
@@ -9083,6 +9306,7 @@ var FLEET_ROSTER_BUDGETS = {
   "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
+  "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -10698,6 +10922,106 @@ var FleetUsageAggregator = class {
     snap.lastEventAt = e.ts;
   }
 };
+
+// src/coordination/subagent-nicknames.ts
+var NICKNAME_POOL = {
+  // Physics & fundamental sciences
+  "einstein": { name: "Einstein", domain: "physics" },
+  "newton": { name: "Newton", domain: "physics" },
+  "feynman": { name: "Feynman", domain: "physics" },
+  "dirac": { name: "Dirac", domain: "physics" },
+  "bohr": { name: "Bohr", domain: "physics" },
+  "planck": { name: "Planck", domain: "physics" },
+  "curie": { name: "Curie", domain: "physics" },
+  "fermi": { name: "Fermi", domain: "physics" },
+  "heisenberg": { name: "Heisenberg", domain: "physics" },
+  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
+  // Mathematics
+  "euclid": { name: "Euclid", domain: "math" },
+  "gauss": { name: "Gauss", domain: "math" },
+  "turing": { name: "Turing", domain: "math" },
+  "poincare": { name: "Poincar\xE9", domain: "math" },
+  "riemann": { name: "Riemann", domain: "math" },
+  "hilbert": { name: "Hilbert", domain: "math" },
+  "pythagoras": { name: "Pythagoras", domain: "math" },
+  // Computing & information theory
+  "von-neumann": { name: "Von Neumann", domain: "computing" },
+  "shannon": { name: "Shannon", domain: "computing" },
+  "hopper": { name: "Hopper", domain: "computing" },
+  "backus": { name: "Backus", domain: "computing" },
+  "knuth": { name: "Knuth", domain: "computing" },
+  "torvalds": { name: "Torvalds", domain: "computing" },
+  "stallman": { name: "Stallman", domain: "computing" },
+  "berners-lee": { name: "Berners-Lee", domain: "computing" },
+  "babbage": { name: "Babbage", domain: "computing" },
+  "lovelace": { name: "Lovelace", domain: "computing" },
+  "klein": { name: "Klein", domain: "computing" },
+  // Electronics & electrical engineering
+  "edison": { name: "Edison", domain: "ee" },
+  "tesla": { name: "Tesla", domain: "ee" },
+  "faraday": { name: "Faraday", domain: "ee" },
+  "maxwell": { name: "Maxwell", domain: "ee" },
+  "ohm": { name: "Ohm", domain: "ee" },
+  "bell": { name: "Bell", domain: "ee" },
+  "marconi": { name: "Marconi", domain: "ee" },
+  "lamarr": { name: "Lamarr", domain: "ee" },
+  // General science / multi-disciplinary
+  "darwin": { name: "Darwin", domain: "biology" },
+  "mendel": { name: "Mendel", domain: "biology" },
+  "pasteur": { name: "Pasteur", domain: "biology" },
+  "hawking": { name: "Hawking", domain: "cosmology" },
+  "sagan": { name: "Sagan", domain: "cosmology" },
+  // Chemistry / materials
+  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
+  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
+};
+var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var DOMAIN_PREFERENCES = {
+  "security": ["shannon", "turing", "lamarr", "stallman"],
+  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
+  "refactor": ["gauss", "hilbert", "euclid", "planck"],
+  "audit-log": ["sagan", "hawking", "poincare", "newton"],
+  "planner": ["hilbert", "gauss", "turing", "euclid"],
+  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
+  "explorer": ["marconi", "bell", "columbus", "polo"],
+  "testing": ["pasteur", "curie", "fermi", "bohr"],
+  "frontend": ["lovelace", "hopper", "babbage", "backus"],
+  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
+  "database": ["turing", "shannon", "backus", "knuth"],
+  "devops": ["tesla", "edison", "faraday", "bell"],
+  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
+  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
+  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
+  "critic": ["einstein", "feynman", "dirac", "bohr"],
+  "e2e": ["hopper", "bell", "marconi", "tesla"],
+  "performance": ["knuth", "gauss", "planck", "feynman"],
+  "chaos": ["tesla", "edison", "curie", "fermi"],
+  "cost": ["oh", "bell", "marconi", "tesla"],
+  // default fallback
+  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
+};
+function assignNickname(role, used) {
+  const preferences = [
+    ...DOMAIN_PREFERENCES[role] ?? [],
+    ...DOMAIN_PREFERENCES["default"] ?? []
+  ];
+  for (const key of preferences) {
+    if (!used.has(key)) {
+      return `${NICKNAME_POOL[key].name} (${formatRole(role)})`;
+    }
+  }
+  for (const entry of ALL_NICKNAMES) {
+    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
+    if (key && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  const counter = used.size + 1;
+  return `Scientist #${counter} (${formatRole(role)})`;
+}
+function formatRole(role) {
+  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -10922,7 +11246,6 @@ function makeFleetSessionTool(director) {
       type: "object",
       properties: {
         subagentId: { type: "string", description: "Subagent id to read the transcript of." },
-        /** Number of trailing lines to return (last N JSONL lines). Default: all. */
         tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
       },
       required: ["subagentId"]
@@ -10958,8 +11281,6 @@ function makeFleetHealthTool(director) {
             id: s.id,
             status: s.status,
             lastEventAt: usage?.lastEventAt,
-            // Budget pressure: fraction of each limit consumed if we have it.
-            // BudgetWarning events carry used/limit ratios; surface them here.
             budgetPressure: {
               iterations: usage?.iterations,
               toolCalls: usage?.toolCalls,
@@ -10971,6 +11292,415 @@ function makeFleetHealthTool(director) {
     }
   };
 }
+function makeCollabDebugTool(director) {
+  return {
+    name: "collab_debug",
+    description: "Start a collaborative debugging session: BugHunter, RefactorPlanner, and Critic run in parallel on the same target files. BugHunter finds bugs and emits bug.found events. RefactorPlanner listens for bug.found and emits refactor.plan events. Critic evaluates both and emits critic.evaluation events. Returns a structured report with overall verdict (approve / needs_revision / reject).",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetPaths: {
+          type: "array",
+          items: { type: "string" },
+          description: "File paths / glob patterns to scan for bugs."
+        },
+        timeoutMs: {
+          type: "number",
+          description: "Timeout in ms. Default: 600000 (10 minutes)."
+        }
+      },
+      required: ["targetPaths"]
+    },
+    async execute(input) {
+      const i = input;
+      if (!i.targetPaths?.length) {
+        return { error: "collab_debug: targetPaths is required and must be non-empty." };
+      }
+      const options = {
+        targetPaths: i.targetPaths,
+        timeoutMs: i.timeoutMs
+      };
+      try {
+        const report = await director.spawnCollab(options);
+        return {
+          sessionId: report.sessionId,
+          overallVerdict: report.overallVerdict,
+          bugCount: report.bugs.length,
+          planCount: report.refactorPlans.length,
+          evaluationCount: report.evaluations.length,
+          summary: report.summary,
+          bugs: report.bugs,
+          refactorPlans: report.refactorPlans,
+          evaluations: report.evaluations
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { error: "collab_debug failed: " + msg };
+      }
+    }
+  };
+}
+function makeFleetEmitTool(director) {
+  return {
+    name: "fleet_emit",
+    description: "Emit a structured event on the FleetBus. Use this when you find a bug (bug.found), complete a refactor plan (refactor.plan), or finish an evaluation (critic.evaluation). Events are routed to other agents in the collab session.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Event type: bug.found | refactor.plan | critic.evaluation"
+        },
+        payload: {
+          type: "object",
+          description: "Event payload matching the event type."
+        }
+      },
+      required: ["type", "payload"]
+    },
+    async execute(input) {
+      const i = input;
+      director.fleet.emit({
+        subagentId: director.id,
+        ts: Date.now(),
+        type: i.type,
+        payload: i.payload
+      });
+      return { ok: true, event: i.type };
+    }
+  };
+}
+var CollabSession = class extends EventEmitter {
+  sessionId;
+  options;
+  snapshot;
+  director;
+  fleetBus;
+  subagentIds = /* @__PURE__ */ new Map();
+  // role → subagentId
+  bugs = /* @__PURE__ */ new Map();
+  plans = /* @__PURE__ */ new Map();
+  evaluations = /* @__PURE__ */ new Map();
+  disposers = new Array();
+  settled = false;
+  timeoutMs;
+  constructor(director, fleetBus, options) {
+    super();
+    this.sessionId = randomUUID();
+    this.options = options;
+    this.director = director;
+    this.fleetBus = fleetBus;
+    this.timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    if (options.prebuiltSnapshot) {
+      this.snapshot = options.prebuiltSnapshot;
+    } else {
+      this.snapshot = {
+        id: this.sessionId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: []
+      };
+    }
+  }
+  /**
+   * Read the target files from disk and populate the snapshot.
+   * Call this after construction if you did not provide a prebuiltSnapshot
+   * and want the session to operate on real file contents.
+   */
+  async buildSnapshot() {
+    if (this.snapshot.files.length > 0) return this.snapshot;
+    for (const filePath of this.options.targetPaths) {
+      try {
+        const content = await fsp.readFile(filePath, "utf8");
+        const ext = filePath.split(".").pop() ?? "";
+        const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
+        this.snapshot.files.push({ path: filePath, content, language });
+      } catch {
+        this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
+      }
+    }
+    return this.snapshot;
+  }
+  /**
+   * Start the collaborative session: snapshot files, spawn all three agents,
+   * wire up event routing, and wait for completion.
+   */
+  async start() {
+    if (this.settled) throw new Error("session already settled");
+    this.settled = true;
+    await this.buildSnapshot();
+    this.wireFleetBus();
+    const [bugHunterId, refactorPlannerId, criticId] = await Promise.all([
+      this.spawnAgent("bug-hunter", this.buildBugHunterTask()),
+      this.spawnAgent("refactor-planner", this.buildRefactorPlannerTask()),
+      this.spawnAgent("critic", this.buildCriticTask())
+    ]);
+    this.subagentIds.set("bug-hunter", bugHunterId);
+    this.subagentIds.set("refactor-planner", refactorPlannerId);
+    this.subagentIds.set("critic", criticId);
+    const timeout = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`)),
+        this.timeoutMs
+      );
+    });
+    let results;
+    try {
+      results = await Promise.race([
+        Promise.all([
+          this.director.awaitTasks([bugHunterId]),
+          this.director.awaitTasks([refactorPlannerId]),
+          this.director.awaitTasks([criticId])
+        ]),
+        timeout
+      ]);
+    } catch (err) {
+      this.cleanup();
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("session.error", error);
+      throw error;
+    }
+    for (const result of results.flat()) {
+      await this.parseAndEmit(result);
+    }
+    const report = this.assembleReport();
+    this.cleanup();
+    this.emit("session.done", report);
+    return report;
+  }
+  /**
+   * Parse a completed agent's final text output and route the structured
+   * findings onto the FleetBus. Agents are instructed to emit one JSON object
+   * per finding / plan / evaluation; we scan the output for balanced JSON
+   * objects (tolerating prose, markdown, and ```json fences around them) and
+   * dispatch each by its discriminating key. The wired FleetBus listeners then
+   * collect them into the bugs / plans / evaluations maps.
+   *
+   * Failed or empty results are ignored, and a single malformed object never
+   * aborts the collation pass — see {@link extractJsonObjects}.
+   */
+  async parseAndEmit(result) {
+    if (result.status !== "success" || result.result == null) return;
+    const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+    for (const obj of this.extractJsonObjects(text)) {
+      const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
+      if (!type) continue;
+      this.fleetBus.emit({
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        ts: Date.now(),
+        type,
+        payload: obj
+      });
+    }
+  }
+  /**
+   * Extract every top-level JSON object embedded in free-form agent text.
+   * Scans for balanced braces while respecting string literals and escape
+   * sequences, so prose, markdown headers, and code fences around the JSON
+   * are skipped. Malformed spans are dropped silently rather than thrown.
+   */
+  extractJsonObjects(text) {
+    const objects = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (ch === "}" && depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          const candidate = text.slice(start, i + 1);
+          try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+              objects.push(parsed);
+            }
+          } catch {
+          }
+          start = -1;
+        }
+      }
+    }
+    return objects;
+  }
+  async spawnAgent(role, taskBrief) {
+    const cfg = {
+      id: `${role}-${this.sessionId}`,
+      name: role,
+      role
+      // No fleet_emit tool — agents output structured JSON, the Director parses
+      // results and emits FleetBus events. This keeps the agent simple and the
+      // routing deterministic.
+    };
+    const subagentId = await this.director.spawn(cfg);
+    await this.director.assign({
+      id: randomUUID(),
+      subagentId,
+      description: taskBrief
+    });
+    return subagentId;
+  }
+  buildBugHunterTask() {
+    this.options.targetPaths.join(", ");
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are BugHunter. Scan the following files for bugs and code smells.
+
+Target files:
+${fileContents}
+
+For each bug found, write ONE valid JSON line to the scratchpad with this exact structure:
+{ "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } }.
+After scanning all files, write your full markdown bug report to the shared scratchpad at:
+${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+  }
+  buildRefactorPlannerTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are RefactorPlanner. Plan refactorings for the following files.
+
+Target files:
+${fileContents}
+
+Listen for bug.found events from BugHunter on the fleet bus. For each bug, create a refactor plan and write one JSON line per plan:
+{ "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [...], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } }.
+After planning, write your full markdown plan to:
+${scratchpad}/refactor-plan-${this.sessionId}.md`;
+  }
+  buildCriticTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are Critic. Evaluate bug findings and refactor plans as they arrive via fleet bus events.
+
+Target files:
+${fileContents}
+
+Subscribe to bug.found events (from BugHunter) and refactor.plan events (from RefactorPlanner). For each subject, write one JSON line per evaluation:
+{ "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": [...], "weaknesses": [...], "concerns": [...] } }.
+After all evaluations, write your markdown critic report to:
+${scratchpad}/critic-report-${this.sessionId}.md`;
+  }
+  wireFleetBus() {
+    const d1 = this.fleetBus.filter("bug.found", (e) => {
+      const payload = e.payload;
+      if (payload?.finding) {
+        this.bugs.set(payload.finding.id, payload.finding);
+        this.emit("bug.found", payload);
+      }
+    });
+    this.disposers.push(d1);
+    const d2 = this.fleetBus.filter("refactor.plan", (e) => {
+      const payload = e.payload;
+      if (payload?.plan) {
+        this.plans.set(payload.plan.id, payload.plan);
+        this.emit("refactor.plan", payload);
+      }
+    });
+    this.disposers.push(d2);
+    const d3 = this.fleetBus.filter("critic.evaluation", (e) => {
+      const payload = e.payload;
+      if (payload?.evaluation) {
+        this.evaluations.set(payload.evaluation.id, payload.evaluation);
+        this.emit("critic.evaluation", payload);
+      }
+    });
+    this.disposers.push(d3);
+  }
+  assembleReport() {
+    const bugList = Array.from(this.bugs.values());
+    const planList = Array.from(this.plans.values());
+    const evalList = Array.from(this.evaluations.values());
+    const verdictOrder = {
+      approve: 0,
+      needs_revision: 1,
+      reject: 2
+    };
+    const overallVerdict = evalList.reduce(
+      (worst, eval_) => {
+        const w = verdictOrder[worst];
+        const c = verdictOrder[eval_.verdict];
+        return c > w ? eval_.verdict : worst;
+      },
+      "approve"
+    );
+    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict);
+    return {
+      sessionId: this.sessionId,
+      startedAt: this.snapshot.createdAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetPaths: this.options.targetPaths,
+      bugs: bugList,
+      refactorPlans: planList,
+      evaluations: evalList,
+      overallVerdict,
+      summary
+    };
+  }
+  buildMarkdownSummary(bugs, plans, evals, overallVerdict) {
+    const lines = [
+      `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
+      "",
+      `**Target:** ${this.options.targetPaths.join(", ")}`,
+      `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
+      ""
+    ];
+    if (bugs.length > 0) {
+      lines.push("### Bugs Found", "");
+      for (const b of bugs) {
+        lines.push(
+          `- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`
+        );
+      }
+      lines.push("");
+    }
+    if (plans.length > 0) {
+      lines.push("### Refactor Plans", "");
+      for (const p of plans) {
+        lines.push(`- **Phase plan** (risk: ${p.riskScore}, ~${p.estimatedChangeCount} changes)`);
+        for (const phase of p.phases) {
+          lines.push(`  - Phase ${phase.number}: ${phase.title} [${phase.risk}]`);
+        }
+      }
+      lines.push("");
+    }
+    if (evals.length > 0) {
+      lines.push("### Critic Evaluations", "");
+      for (const e of evals) {
+        lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
+        for (const c of e.concerns) {
+          if (c.severity === "blocking") {
+            lines.push(`  - ${c.description}`);
+          }
+        }
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  cleanup() {
+    for (const dispose of this.disposers) dispose();
+    this.disposers.length = 0;
+  }
+};
 
 // src/coordination/director.ts
 var FleetSpawnBudgetError = class extends Error {
@@ -11049,6 +11779,8 @@ var Director = class {
   subagentBridges = /* @__PURE__ */ new Map();
   /** Tracks per-spawn config + assigned task ids for manifest writing. */
   manifestEntries = /* @__PURE__ */ new Map();
+  /** Tracks assigned nicknames so the same name is never reused in one fleet. */
+  _usedNicknames = /* @__PURE__ */ new Set();
   manifestPath;
   roster;
   directorPreamble;
@@ -11342,9 +12074,21 @@ var Director = class {
       }
     }
     let result;
+    const needsNickname = config.name === config.role || !config.name || config.name === "subagent";
+    if (needsNickname) {
+      const role = config.role ?? "subagent";
+      if (this.fleetManager) {
+        this.fleetManager.assignNicknameAndRecord("", config, priceLookup);
+      } else {
+        config.name = assignNickname(role, this._usedNicknames);
+        this._usedNicknames.add(config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-"));
+      }
+    }
     result = await this.coordinator.spawn(config);
     if (this.fleetManager) {
-      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+      if (!needsNickname) {
+        this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+      }
     } else {
       this.spawnCount += 1;
       this.subagentMeta.set(result.subagentId, {
@@ -11780,7 +12524,9 @@ var Director = class {
       makeFleetStatusTool(this),
       makeFleetUsageTool(this),
       makeFleetSessionTool(this),
-      makeFleetHealthTool(this)
+      makeFleetHealthTool(this),
+      makeCollabDebugTool(this),
+      makeFleetEmitTool(this)
     ];
     return t;
   }
@@ -11792,6 +12538,17 @@ var Director = class {
   async acquireCheckpointLock() {
     return this.stateCheckpoint ? this.stateCheckpoint.acquireLock() : true;
   }
+  /**
+   * Start a collaborative debugging session: BugHunter, RefactorPlanner,
+   * and Critic run in parallel on the same target files, with findings
+   * flowing through the FleetBus (bug.found → refactor.plan →
+   * critic.evaluation). Returns a structured CollabDebugReport when all
+   * three agents complete or the session times out.
+   */
+  async spawnCollab(options) {
+    const session = new CollabSession(this, this.fleet, options);
+    return session.start();
+  }
   /**
    * Resume from a prior checkpoint snapshot (loaded via
    * `loadDirectorState()`). Re-attach to the fleet mid-flight so
@@ -14025,10 +14782,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp14 = await import('fs/promises');
+      const fsp15 = await import('fs/promises');
       const path18 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp14.mkdir(path18.dirname(this.sessionPath), { recursive: true });
+      await fsp15.mkdir(path18.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -14037,8 +14794,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp14 = await import('fs/promises');
-      const raw = await fsp14.readFile(this.sessionPath, "utf8");
+      const fsp15 = await import('fs/promises');
+      const raw = await fsp15.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -14052,8 +14809,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp14 = await import('fs/promises');
-      await fsp14.unlink(this.sessionPath);
+      const fsp15 = await import('fs/promises');
+      await fsp15.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -16420,6 +17177,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, makeLLMClassifier, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map