squadrant 0.28.1 → 0.29.0

package/dist/squadrantd.js

@@ -417,6 +417,18 @@ var init_knowledge = __esm({
   }
 });
 
+// packages/shared/dist/workspace.js
+import fs2 from "fs";
+import os3 from "os";
+import path5 from "path";
+var workspaceRoot, workspacePath;
+var init_workspace = __esm({
+  "packages/shared/dist/workspace.js"() {
+    workspaceRoot = () => process.env.SQUADRANT_WORKSPACE_DIR || path5.join(os3.homedir(), "squadrant", "workspace");
+    workspacePath = (project) => path5.join(workspaceRoot(), project);
+  }
+});
+
 // packages/shared/dist/router-model.js
 function resolveRouterModel(model, agentName, router) {
   if (!model)
@@ -484,22 +496,22 @@ function defaultCmuxConfigPath() {
   return join(homedir(), ".config", "cmux", "cmux.json");
 }
 function ensureSocketAutomation(opts = {}) {
-  const path43 = opts.path ?? defaultCmuxConfigPath();
-  if (!existsSync(path43)) {
-    mkdirSync(dirname(path43), { recursive: true });
-    writeFileSync(path43, MINIMAL_TEMPLATE);
-    return { path: path43, changed: true, alreadySet: false };
+  const path44 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path44)) {
+    mkdirSync(dirname(path44), { recursive: true });
+    writeFileSync(path44, MINIMAL_TEMPLATE);
+    return { path: path44, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path43, "utf-8");
+  const text = readFileSync(path44, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path43, changed: false, alreadySet: true };
+    return { path: path44, changed: false, alreadySet: true };
   }
   const edits = modify(text, [...SOCKET_CONTROL_MODE_PATH], AUTOMATION_MODE, {
     formattingOptions: { insertSpaces: true, tabSize: 2 }
   });
-  writeFileSync(path43, applyEdits(text, edits));
-  return { path: path43, changed: true, alreadySet: false };
+  writeFileSync(path44, applyEdits(text, edits));
+  return { path: path44, changed: true, alreadySet: false };
 }
 var SOCKET_CONTROL_MODE_PATH, AUTOMATION_MODE, MINIMAL_TEMPLATE;
 var init_cmux_config = __esm({
@@ -642,16 +654,75 @@ writeFileSync(resultFile, JSON.stringify(result));
   }
 });
 
-// packages/shared/dist/lib/cmux-autoconfig.js
-import { existsSync as existsSync4, rmSync as rmSync2 } from "fs";
+// packages/shared/dist/lib/state-paths.js
+import { cpSync, existsSync as existsSync4, readdirSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { dirname as dirname2, join as join4, resolve } from "path";
+function isolatedConfigDir() {
+  const cfg = process.env.SQUADRANT_CONFIG;
+  if (!cfg || resolve(cfg) === join4(defaultConfigDir(), "config.json"))
+    return null;
+  return dirname2(resolve(cfg));
+}
+function stateRoot() {
+  if (process.env.SQUADRANT_STATE_DIR)
+    return process.env.SQUADRANT_STATE_DIR;
+  const isolated = isolatedConfigDir();
+  if (isolated)
+    return join4(isolated, "state");
+  return join4(process.env.XDG_STATE_HOME || join4(homedir3(), ".local", "state"), "squadrant");
+}
+function logsRoot() {
+  return join4(stateRoot(), "logs");
+}
+function daemonLogPath() {
+  return join4(logsRoot(), "squadrantd.log");
+}
+function legacyStateDir() {
+  return join4(isolatedConfigDir() ?? defaultConfigDir(), "state");
+}
+function legacyDaemonLogPath() {
+  return join4(isolatedConfigDir() ?? defaultConfigDir(), "squadrantd.log");
+}
+function stateSeedMarkerPath(root = stateRoot()) {
+  return join4(root, ".seeded-from-legacy");
+}
+function resolveReadPath(newPath, legacyPath) {
+  if (existsSync4(newPath) || !existsSync4(legacyPath))
+    return newPath;
+  return legacyPath;
+}
+function seedStateFromLegacy(opts = {}) {
+  const root = opts.root ?? stateRoot();
+  const legacy = opts.legacy ?? legacyStateDir();
+  if (resolve(root) === resolve(legacy))
+    return { seeded: false, reason: "same-dir" };
+  const marker = stateSeedMarkerPath(root);
+  if (existsSync4(marker))
+    return { seeded: false, reason: "already-seeded" };
+  if (!existsSync4(legacy) || readdirSync(legacy).length === 0)
+    return { seeded: false, reason: "no-legacy-data" };
+  mkdirSync2(root, { recursive: true });
+  cpSync(legacy, root, { recursive: true, force: false, errorOnExist: false });
+  writeFileSync3(marker, JSON.stringify({ from: legacy, at: (/* @__PURE__ */ new Date()).toISOString() }) + "\n");
+  return { seeded: true, reason: "seeded" };
+}
+var defaultConfigDir;
+var init_state_paths = __esm({
+  "packages/shared/dist/lib/state-paths.js"() {
+    defaultConfigDir = () => join4(homedir3(), ".config", "squadrant");
+  }
+});
+
+// packages/shared/dist/lib/cmux-autoconfig.js
+import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+import { join as join5 } from "path";
 function defaultStatePath() {
-  return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
+  return join5(stateRoot(), "cmux-autoconfig.json");
 }
-function readState(path43) {
+function readState(path44) {
   try {
-    return JSON.parse(readConfigFileSync(path43));
+    return JSON.parse(readConfigFileSync(path44));
   } catch {
     return {};
   }
@@ -671,7 +742,7 @@ async function ensureCmuxAutoConfig(opts = {}) {
       promptedThisRun = true;
     }
   } else if (verdict === "reachable") {
-    if (existsSync4(statePath3))
+    if (existsSync5(statePath3))
       rmSync2(statePath3, { force: true });
   }
   return {
@@ -688,6 +759,7 @@ var init_cmux_autoconfig = __esm({
     init_cmux_config();
     init_cmux_probe();
     init_config_io();
+    init_state_paths();
   }
 });
 
@@ -723,14 +795,14 @@ var init_config_version = __esm({
 });
 
 // packages/shared/dist/lib/update-check.js
-import fs2 from "fs";
-import path5 from "path";
-import os3 from "os";
+import fs3 from "fs";
+import path6 from "path";
+import os4 from "os";
 import https from "https";
 var UPDATE_CHECK_STATE_PATH, CHECK_INTERVAL_MS, FAILURE_RETRY_MS;
 var init_update_check = __esm({
   "packages/shared/dist/lib/update-check.js"() {
-    UPDATE_CHECK_STATE_PATH = path5.join(os3.homedir(), ".config", "squadrant", "update-check.json");
+    UPDATE_CHECK_STATE_PATH = path6.join(os4.homedir(), ".config", "squadrant", "update-check.json");
     CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
     FAILURE_RETRY_MS = 60 * 60 * 1e3;
   }
@@ -738,10 +810,10 @@ var init_update_check = __esm({
 
 // packages/shared/dist/lib/git-worktree.js
 import { execFileSync as execFileSync2 } from "child_process";
-import fs3 from "fs";
-import path6 from "path";
+import fs4 from "fs";
+import path7 from "path";
 function worktreePath(repoRoot, worktreeDir, project, name) {
-  return path6.resolve(repoRoot, worktreeDir, `${project}-${name}`);
+  return path7.resolve(repoRoot, worktreeDir, `${project}-${name}`);
 }
 function crewBranch(name) {
   return `crew/${name}`;
@@ -750,11 +822,11 @@ function ensureSpotlightExcluded(repoRoot, worktreeDir) {
   if (process.platform !== "darwin")
     return;
   try {
-    const dir = path6.resolve(repoRoot, worktreeDir);
-    fs3.mkdirSync(dir, { recursive: true });
-    const marker = path6.join(dir, ".metadata_never_index");
-    if (!fs3.existsSync(marker))
-      fs3.writeFileSync(marker, "");
+    const dir = path7.resolve(repoRoot, worktreeDir);
+    fs4.mkdirSync(dir, { recursive: true });
+    const marker = path7.join(dir, ".metadata_never_index");
+    if (!fs4.existsSync(marker))
+      fs4.writeFileSync(marker, "");
   } catch {
   }
 }
@@ -816,15 +888,15 @@ function addWorktree(spec) {
   return wt;
 }
 function installWorktreeDependencies(wt) {
-  if (!fs3.existsSync(path6.join(wt, "package.json")))
+  if (!fs4.existsSync(path7.join(wt, "package.json")))
     return;
-  if (fs3.existsSync(path6.join(wt, "pnpm-lock.yaml"))) {
+  if (fs4.existsSync(path7.join(wt, "pnpm-lock.yaml"))) {
     execFileSync2("pnpm", ["-C", wt, "install", "--frozen-lockfile"], { stdio: "pipe" });
-  } else if (fs3.existsSync(path6.join(wt, "yarn.lock"))) {
+  } else if (fs4.existsSync(path7.join(wt, "yarn.lock"))) {
     execFileSync2("yarn", ["install", "--frozen-lockfile"], { cwd: wt, stdio: "pipe" });
-  } else if (fs3.existsSync(path6.join(wt, "package-lock.json"))) {
+  } else if (fs4.existsSync(path7.join(wt, "package-lock.json"))) {
     execFileSync2("npm", ["ci"], { cwd: wt, stdio: "pipe" });
-  } else if (fs3.existsSync(path6.join(wt, "bun.lockb"))) {
+  } else if (fs4.existsSync(path7.join(wt, "bun.lockb"))) {
     execFileSync2("bun", ["install", "--frozen-lockfile"], { cwd: wt, stdio: "pipe" });
   } else {
     process.stderr.write(`worktree ${wt}: package.json present but no lockfile \u2014 dependencies not installed; local typechecks/tests may resolve against the main checkout instead of this worktree.
@@ -843,7 +915,7 @@ function worktreeDirtyFiles(wtPath) {
 }
 function removeGeneratedWorktreeFiles(wtPath) {
   for (const [, file] of worktreeStatus(wtPath).filter(isGeneratedUntracked)) {
-    fs3.rmSync(path6.join(wtPath, file), { force: true });
+    fs4.rmSync(path7.join(wtPath, file), { force: true });
   }
 }
 function removeWorktree(repoRoot, wtPath, opts) {
@@ -859,15 +931,15 @@ var init_git_worktree = __esm({
 });
 
 // packages/shared/dist/lib/resolve-text-input.js
-import fs4 from "fs";
+import fs5 from "fs";
 var init_resolve_text_input = __esm({
   "packages/shared/dist/lib/resolve-text-input.js"() {
   }
 });
 
 // packages/shared/dist/lib/runtime-sync.js
-import fs5 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path8 from "path";
 var init_runtime_sync = __esm({
   "packages/shared/dist/lib/runtime-sync.js"() {
   }
@@ -909,8 +981,8 @@ var init_tool_compat = __esm({
 });
 
 // packages/shared/dist/lib/canonical-source.js
-import fs6 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path9 from "path";
 var init_canonical_source = __esm({
   "packages/shared/dist/lib/canonical-source.js"() {
   }
@@ -918,8 +990,8 @@ var init_canonical_source = __esm({
 
 // packages/shared/dist/lib/daily-logs.js
 import { execSync } from "child_process";
-import fs7 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path10 from "path";
 import matter from "gray-matter";
 var init_daily_logs = __esm({
   "packages/shared/dist/lib/daily-logs.js"() {
@@ -942,12 +1014,6 @@ var init_session_name = __esm({
   }
 });
 
-// packages/shared/dist/lib/vault-layout.js
-var init_vault_layout = __esm({
-  "packages/shared/dist/lib/vault-layout.js"() {
-  }
-});
-
 // packages/shared/dist/daemon-keys.js
 var init_daemon_keys = __esm({
   "packages/shared/dist/daemon-keys.js"() {
@@ -962,6 +1028,7 @@ var init_dist = __esm({
     init_project_config();
     init_effort();
     init_knowledge();
+    init_workspace();
     init_router_model();
     init_runtime();
     init_liveness();
@@ -985,7 +1052,7 @@ var init_dist = __esm({
     init_canonical_source();
     init_daily_logs();
     init_session_name();
-    init_vault_layout();
+    init_state_paths();
     init_daemon_keys();
   }
 });
@@ -1670,33 +1737,33 @@ var init_reduce = __esm({
 });
 
 // packages/core/dist/mailbox.js
-import { promises as fs8 } from "fs";
-import { join as join5 } from "path";
+import { promises as fs9 } from "fs";
+import { join as join6 } from "path";
 import { randomUUID } from "crypto";
-function inboxDir(stateRoot) {
-  return join5(stateRoot, "inbox");
+function inboxDir(stateRoot2) {
+  return join6(stateRoot2, "inbox");
 }
-function logPath(stateRoot, project) {
-  return join5(inboxDir(stateRoot), `${project}.log`);
+function logPath(stateRoot2, project) {
+  return join6(inboxDir(stateRoot2), `${project}.log`);
 }
 function extractPayload(event) {
   const { type: _type, id: _id, ...payload } = event;
   return payload;
 }
-async function listRotatedOldestFirst(stateRoot, project) {
-  const dir = inboxDir(stateRoot);
+async function listRotatedOldestFirst(stateRoot2, project) {
+  const dir = inboxDir(stateRoot2);
   let entries;
   try {
-    entries = await fs8.readdir(dir);
+    entries = await fs9.readdir(dir);
   } catch {
     return [];
   }
   const prefix = `${project}.log.`;
-  return entries.filter((e) => e.startsWith(prefix) && /^\d+$/.test(e.slice(prefix.length))).map((e) => ({ name: e, n: Number(e.slice(prefix.length)) })).sort((a, b) => b.n - a.n).map((e) => join5(dir, e.name));
+  return entries.filter((e) => e.startsWith(prefix) && /^\d+$/.test(e.slice(prefix.length))).map((e) => ({ name: e, n: Number(e.slice(prefix.length)) })).sort((a, b) => b.n - a.n).map((e) => join6(dir, e.name));
 }
 async function readMaxSeqFromFile(file) {
   try {
-    const buf = await fs8.readFile(file, "utf-8");
+    const buf = await fs9.readFile(file, "utf-8");
     if (!buf.trim())
       return 0;
     const lines = buf.trim().split("\n");
@@ -1715,11 +1782,11 @@ async function readMaxSeqFromFile(file) {
     throw e;
   }
 }
-async function readMaxSeq(stateRoot, project) {
+async function readMaxSeq(stateRoot2, project) {
   let max = 0;
   const files = [
-    logPath(stateRoot, project),
-    ...await listRotatedOldestFirst(stateRoot, project)
+    logPath(stateRoot2, project),
+    ...await listRotatedOldestFirst(stateRoot2, project)
   ];
   for (const file of files) {
     const seq2 = await readMaxSeqFromFile(file);
@@ -1734,15 +1801,15 @@ function withProjectLock(project, fn) {
   projectLocks.set(project, next.catch(() => void 0));
   return next;
 }
-function appendEntry(stateRoot, project, build) {
+function appendEntry(stateRoot2, project, build) {
   return withProjectLock(project, async () => {
-    const dir = inboxDir(stateRoot);
-    await fs8.mkdir(dir, { recursive: true });
-    const file = logPath(stateRoot, project);
-    const lastSeq = await readMaxSeq(stateRoot, project);
+    const dir = inboxDir(stateRoot2);
+    await fs9.mkdir(dir, { recursive: true });
+    const file = logPath(stateRoot2, project);
+    const lastSeq = await readMaxSeq(stateRoot2, project);
     const seq2 = lastSeq + 1;
     const entry = build(seq2);
-    await fs8.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    await fs9.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
     return seq2;
   });
 }
@@ -1767,13 +1834,13 @@ async function appendCaptainMessage(opts) {
     message: opts.text
   }));
 }
-function cursorPath(stateRoot, project, subscriber) {
-  return join5(inboxDir(stateRoot), `${project}.${subscriber}.cursor`);
+function cursorPath(stateRoot2, project, subscriber) {
+  return join6(inboxDir(stateRoot2), `${project}.${subscriber}.cursor`);
 }
 async function readCursor(opts) {
   let buf;
   try {
-    buf = await fs8.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
+    buf = await fs9.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
   } catch (e) {
     if (e.code === "ENOENT")
       return null;
@@ -1800,7 +1867,7 @@ async function waitForCaptainDelivery(opts) {
   }
 }
 async function writeCursor(opts) {
-  await fs8.mkdir(inboxDir(opts.stateRoot), { recursive: true });
+  await fs9.mkdir(inboxDir(opts.stateRoot), { recursive: true });
   const dest = cursorPath(opts.stateRoot, opts.project, opts.subscriber);
   const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
   const data = {
@@ -1808,7 +1875,7 @@ async function writeCursor(opts) {
     subscriber: opts.subscriber,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const handle = await fs8.open(tmp, "w");
+  const handle = await fs9.open(tmp, "w");
   try {
     await handle.writeFile(JSON.stringify(data), { encoding: "utf-8" });
     await handle.sync();
@@ -1816,9 +1883,9 @@ async function writeCursor(opts) {
     await handle.close();
   }
   try {
-    await fs8.rename(tmp, dest);
+    await fs9.rename(tmp, dest);
   } catch (e) {
-    await fs8.unlink(tmp).catch(() => {
+    await fs9.unlink(tmp).catch(() => {
     });
     throw e;
   }
@@ -1829,7 +1896,7 @@ async function* readFromCursor(opts) {
   for (const file of files) {
     let buf;
     try {
-      buf = await fs8.readFile(file, "utf-8");
+      buf = await fs9.readFile(file, "utf-8");
     } catch (e) {
       if (e.code === "ENOENT")
         continue;
@@ -1849,13 +1916,13 @@ async function* readFromCursor(opts) {
     }
   }
 }
-async function mailboxStats(stateRoot, project) {
-  const file = logPath(stateRoot, project);
-  const rotated = await listRotatedOldestFirst(stateRoot, project);
+async function mailboxStats(stateRoot2, project) {
+  const file = logPath(stateRoot2, project);
+  const rotated = await listRotatedOldestFirst(stateRoot2, project);
   let sizeBytes = 0;
   for (const f of [file, ...rotated]) {
     try {
-      sizeBytes += (await fs8.stat(f)).size;
+      sizeBytes += (await fs9.stat(f)).size;
     } catch (e) {
       if (e.code !== "ENOENT")
         throw e;
@@ -1863,7 +1930,7 @@ async function mailboxStats(stateRoot, project) {
   }
   const oldestFile = rotated[0] ?? file;
   return {
-    maxSeq: await readMaxSeq(stateRoot, project),
+    maxSeq: await readMaxSeq(stateRoot2, project),
     sizeBytes,
     oldestEntryAgeMs: await oldestEntryAgeMs(oldestFile),
     rotationCount: rotated.length
@@ -1871,7 +1938,7 @@ async function mailboxStats(stateRoot, project) {
 }
 async function oldestEntryAgeMs(file) {
   try {
-    const buf = await fs8.readFile(file, "utf-8");
+    const buf = await fs9.readFile(file, "utf-8");
     const firstLine = buf.split("\n").find((l) => l.trim());
     if (!firstLine)
       return 0;
@@ -1886,7 +1953,7 @@ async function rotateIfNeeded(opts) {
     const file = logPath(opts.stateRoot, opts.project);
     let size = 0;
     try {
-      size = (await fs8.stat(file)).size;
+      size = (await fs9.stat(file)).size;
     } catch (e) {
       if (e.code === "ENOENT")
         return { rotated: false };
@@ -1902,22 +1969,22 @@ async function rotateIfNeeded(opts) {
       const dst = `${file}.${n + 1}`;
       if (n + 1 > opts.keepCount) {
         try {
-          await fs8.unlink(src);
+          await fs9.unlink(src);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       } else {
         try {
-          await fs8.rename(src, dst);
+          await fs9.rename(src, dst);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       }
     }
-    await fs8.rename(file, `${file}.1`);
-    await fs8.writeFile(file, "", { encoding: "utf-8" });
+    await fs9.rename(file, `${file}.1`);
+    await fs9.writeFile(file, "", { encoding: "utf-8" });
     return { rotated: true, from: file, to: `${file}.1` };
   });
 }
@@ -1930,7 +1997,7 @@ var init_mailbox = __esm({
 
 // packages/core/dist/protocol.js
 import { createServer, createConnection } from "net";
-import { existsSync as existsSync5, unlinkSync, chmodSync } from "fs";
+import { existsSync as existsSync6, unlinkSync, chmodSync } from "fs";
 function encodeMsg(obj) {
   return JSON.stringify(obj) + "\n";
 }
@@ -1975,7 +2042,7 @@ function startServer(sockPath, handlerOrCallbacks, onListenError = defaultListen
   const { handler, onAttach, onAttachInbound, onAttachClose } = callbacks;
   const setIntervalFn = deps.setInterval ?? setInterval;
   const clearIntervalFn = deps.clearInterval ?? clearInterval;
-  if (existsSync5(sockPath)) {
+  if (existsSync6(sockPath)) {
     try {
       unlinkSync(sockPath);
     } catch {
@@ -2053,9 +2120,9 @@ function startServer(sockPath, handlerOrCallbacks, onListenError = defaultListen
   return server;
 }
 function isDaemonSocketLive(sockPath, timeoutMs = 500) {
-  return new Promise((resolve4) => {
-    if (!existsSync5(sockPath)) {
-      resolve4(false);
+  return new Promise((resolve5) => {
+    if (!existsSync6(sockPath)) {
+      resolve5(false);
       return;
     }
     const conn = createConnection(sockPath);
@@ -2064,7 +2131,7 @@ function isDaemonSocketLive(sockPath, timeoutMs = 500) {
         conn.destroy();
       } catch {
       }
-      resolve4(v2);
+      resolve5(v2);
     };
     const timer = setTimeout(() => finish(false), timeoutMs);
     conn.on("connect", () => {
@@ -2078,7 +2145,7 @@ function isDaemonSocketLive(sockPath, timeoutMs = 500) {
   });
 }
 function sendRequest(sockPath, msg, timeoutMs = 5e3) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const conn = createConnection(sockPath);
     const dec = createDecoder();
     const timer = setTimeout(() => {
@@ -2094,7 +2161,7 @@ function sendRequest(sockPath, msg, timeoutMs = 5e3) {
         if (m._v !== void 0 && m._v !== PROTOCOL_VERSION) {
           reject(new Error(`squadrantd protocol v${m._v}, this client expects v${PROTOCOL_VERSION} \u2014 upgrade squadrantd or this CLI`));
         } else if (m.ok) {
-          resolve4(m.reply);
+          resolve5(m.reply);
         } else {
           reject(new Error(m.error));
         }
@@ -2243,8 +2310,8 @@ var init_liveness2 = __esm({
 });
 
 // packages/core/dist/store.js
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync, renameSync, writeFileSync as writeFileSync3, existsSync as existsSync6, rmSync as rmSync3, statSync } from "fs";
-import { join as join6, resolve, sep } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, renameSync, writeFileSync as writeFileSync4, existsSync as existsSync7, rmSync as rmSync3, statSync } from "fs";
+import { join as join7, resolve as resolve2, sep } from "path";
 function safeSegment(kind, s) {
   if (typeof s !== "string" || s.length === 0) {
     throw new Error(`invalid ${kind}: must be a non-empty string`);
@@ -2263,19 +2330,19 @@ function isTaskRecord(r) {
   return typeof rec.id === "string" && rec.id.length > 0 && typeof rec.project === "string" && rec.project.length > 0;
 }
 function createStore(root) {
-  const rootResolved = resolve(root);
+  const rootResolved = resolve2(root);
   const assertUnderRoot = (target) => {
-    const r = resolve(target);
+    const r = resolve2(target);
     if (r !== rootResolved && !r.startsWith(rootResolved + sep)) {
       throw new Error(`path escapes state root: ${target}`);
     }
     return target;
   };
-  const projDir = (p) => assertUnderRoot(join6(root, safeSegment("project", p)));
-  const taskFile = (p, id) => assertUnderRoot(join6(projDir(p), `${safeSegment("id", id)}.json`));
+  const projDir = (p) => assertUnderRoot(join7(root, safeSegment("project", p)));
+  const taskFile = (p, id) => assertUnderRoot(join7(projDir(p), `${safeSegment("id", id)}.json`));
   const readRecord = (project, id) => {
     const f = taskFile(project, id);
-    if (!existsSync6(f))
+    if (!existsSync7(f))
       return void 0;
     try {
       return JSON.parse(readFileSync4(f, "utf-8"));
@@ -2290,10 +2357,10 @@ function createStore(root) {
         console.error(`[squadrant] REJECTED terminal\u2192terminal overwrite of ${rec.project}/${rec.id}: already ${existing.state}/${existing.lastEvent} \u2014 refusing ${rec.state}/${rec.lastEvent}; original terminal record preserved (#595)`);
         return;
       }
-      mkdirSync2(projDir(rec.project), { recursive: true });
+      mkdirSync3(projDir(rec.project), { recursive: true });
       const dest = taskFile(rec.project, rec.id);
       const tmp = `${dest}.tmp`;
-      writeFileSync3(tmp, JSON.stringify(rec, null, 2));
+      writeFileSync4(tmp, JSON.stringify(rec, null, 2));
       renameSync(tmp, dest);
     },
     get(project, id) {
@@ -2301,22 +2368,22 @@ function createStore(root) {
     },
     list(project) {
       const d = projDir(project);
-      if (!existsSync6(d))
+      if (!existsSync7(d))
         return [];
-      return readdirSync(d).filter((n) => n.endsWith(".json")).map((n) => {
+      return readdirSync2(d).filter((n) => n.endsWith(".json")).map((n) => {
         try {
-          return JSON.parse(readFileSync4(join6(d, n), "utf-8"));
+          return JSON.parse(readFileSync4(join7(d, n), "utf-8"));
         } catch {
           return void 0;
         }
       }).filter(isTaskRecord);
     },
     listAll() {
-      if (!existsSync6(root))
+      if (!existsSync7(root))
         return [];
-      return readdirSync(root).filter((p) => {
+      return readdirSync2(root).filter((p) => {
         try {
-          return statSync(join6(root, p)).isDirectory();
+          return statSync(join7(root, p)).isDirectory();
         } catch {
           return false;
         }
@@ -2324,12 +2391,12 @@ function createStore(root) {
     },
     quarantine(project, id) {
       const f = taskFile(project, id);
-      if (existsSync6(f))
+      if (existsSync7(f))
         renameSync(f, `${f}.corrupt.${Date.now()}`);
     },
     delete(project, id) {
       const f = taskFile(project, id);
-      if (existsSync6(f))
+      if (existsSync7(f))
         rmSync3(f);
     }
   };
@@ -2342,11 +2409,11 @@ var init_store = __esm({
 
 // packages/core/dist/work-store.js
 import { homedir as homedir4 } from "os";
-import { join as join7, resolve as resolve2, sep as sep2 } from "path";
+import { join as join8, resolve as resolve3, sep as sep2 } from "path";
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, renameSync as renameSync2, writeFileSync as writeFileSync4, existsSync as existsSync7, rmSync as rmSync4, statSync as statSync2 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, renameSync as renameSync2, writeFileSync as writeFileSync5, existsSync as existsSync8, rmSync as rmSync4, statSync as statSync2 } from "fs";
 function defaultWorkRoot() {
-  return join7(homedir4(), ".config", "squadrant", "work");
+  return join8(homedir4(), ".config", "squadrant", "work");
 }
 function safeSegment2(kind, s) {
   if (typeof s !== "string" || s.length === 0) {
@@ -2360,27 +2427,27 @@ function safeSegment2(kind, s) {
   return s;
 }
 function createWorkStore(root = defaultWorkRoot()) {
-  const rootResolved = resolve2(root);
+  const rootResolved = resolve3(root);
   const assertUnderRoot = (target) => {
-    const r = resolve2(target);
+    const r = resolve3(target);
     if (r !== rootResolved && !r.startsWith(rootResolved + sep2)) {
       throw new Error(`path escapes state root: ${target}`);
     }
     return target;
   };
-  const projDir = (p) => assertUnderRoot(join7(root, safeSegment2("project", p)));
-  const itemFile = (p, id) => assertUnderRoot(join7(projDir(p), `${safeSegment2("id", id)}.json`));
+  const projDir = (p) => assertUnderRoot(join8(root, safeSegment2("project", p)));
+  const itemFile = (p, id) => assertUnderRoot(join8(projDir(p), `${safeSegment2("id", id)}.json`));
   return {
     put(item) {
-      mkdirSync3(projDir(item.project), { recursive: true });
+      mkdirSync4(projDir(item.project), { recursive: true });
       const dest = itemFile(item.project, item.id);
       const tmp = `${dest}.tmp`;
-      writeFileSync4(tmp, JSON.stringify(item, null, 2));
+      writeFileSync5(tmp, JSON.stringify(item, null, 2));
       renameSync2(tmp, dest);
     },
     get(project, id) {
       const f = itemFile(project, id);
-      if (!existsSync7(f))
+      if (!existsSync8(f))
         return void 0;
       try {
         return JSON.parse(readFileSync5(f, "utf-8"));
@@ -2390,22 +2457,22 @@ function createWorkStore(root = defaultWorkRoot()) {
     },
     list(project) {
       const d = projDir(project);
-      if (!existsSync7(d))
+      if (!existsSync8(d))
         return [];
-      return readdirSync2(d).filter((n) => n.endsWith(".json") && !n.endsWith(".json.tmp")).map((n) => {
+      return readdirSync3(d).filter((n) => n.endsWith(".json") && !n.endsWith(".json.tmp")).map((n) => {
         try {
-          return JSON.parse(readFileSync5(join7(d, n), "utf-8"));
+          return JSON.parse(readFileSync5(join8(d, n), "utf-8"));
         } catch {
           return void 0;
         }
       }).filter((r) => r !== void 0);
     },
     listAll() {
-      if (!existsSync7(root))
+      if (!existsSync8(root))
         return [];
-      return readdirSync2(root).filter((p) => {
+      return readdirSync3(root).filter((p) => {
         try {
-          return statSync2(join7(root, p)).isDirectory();
+          return statSync2(join8(root, p)).isDirectory();
         } catch {
           return false;
         }
@@ -2413,7 +2480,7 @@ function createWorkStore(root = defaultWorkRoot()) {
     },
     delete(project, id) {
       const f = itemFile(project, id);
-      if (existsSync7(f))
+      if (existsSync8(f))
         rmSync4(f);
     }
   };
@@ -2539,16 +2606,16 @@ var init_snapshot = __esm({
 
 // packages/core/dist/launchd.js
 import { execFileSync as execFileSync3 } from "child_process";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync8, openSync, writeSync, closeSync, unlinkSync as unlinkSync2, constants } from "fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6, readFileSync as readFileSync6, existsSync as existsSync9, openSync, writeSync, closeSync, unlinkSync as unlinkSync2, constants } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 import { fileURLToPath } from "url";
 function plistPath() {
-  return join8(homedir5(), "Library", "LaunchAgents", `${LABEL}.plist`);
+  return join9(homedir5(), "Library", "LaunchAgents", `${LABEL}.plist`);
 }
 function daemonEntryPath() {
-  const p = join8(dirname2(fileURLToPath(import.meta.url)), "squadrantd.js");
-  if (!existsSync8(p)) {
+  const p = join9(dirname3(fileURLToPath(import.meta.url)), "squadrantd.js");
+  if (!existsSync9(p)) {
     throw new Error(`daemonEntryPath: compiled entry not found at '${p}'; run 'npm run build' \u2014 a src-tree or missing path in the launchd plist causes a MODULE_NOT_FOUND crash-loop (#259)`);
   }
   return p;
@@ -2598,10 +2665,10 @@ function detectForeignInstall(parsed, thisEntry, registeredEntryExists) {
     isUpgrade: isVersionUpgrade(parsed.daemonEntry, thisEntry)
   };
 }
-function sanitizePathForPlist(path43) {
+function sanitizePathForPlist(path44) {
   const seen = /* @__PURE__ */ new Set();
   const stable = [];
-  for (const p of path43.split(":")) {
+  for (const p of path44.split(":")) {
     if (!p)
       continue;
     if (p.includes("/.claude/plugins/"))
@@ -2624,7 +2691,7 @@ function resolveAgentBinDirs() {
       const out = execFileSync3("which", [bin], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
       const resolved = out.trim();
       if (resolved)
-        dirs.push(dirname2(resolved));
+        dirs.push(dirname3(resolved));
     } catch {
     }
   }
@@ -2640,7 +2707,7 @@ function buildDaemonPath(shellPath) {
   return sanitizePathForPlist([...resolveAgentBinDirs(), shellPath].join(":"));
 }
 function renderPlist(nodeBin, daemonEntry, pathEnv = "") {
-  const logPath2 = join8(homedir5(), ".config", "squadrant", "squadrantd.log");
+  const logPath2 = daemonLogPath();
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -2669,11 +2736,11 @@ function _resetRestartInFlightForTest() {
   restartInFlight = false;
 }
 function daemonLockPath() {
-  return join8(homedir5(), ".config", "squadrant", "daemon.lock");
+  return join9(homedir5(), ".config", "squadrant", "daemon.lock");
 }
 function tryAcquireDaemonLock() {
   const lp = daemonLockPath();
-  if (existsSync8(lp)) {
+  if (existsSync9(lp)) {
     try {
       const pid = parseInt(readFileSync6(lp, "utf-8").trim(), 10);
       if (!Number.isFinite(pid) || pid <= 0) {
@@ -2712,19 +2779,20 @@ function computeDaemonDrift(nodeBin) {
   const p = plistPath();
   const entry = daemonEntryPath();
   const desired = renderPlist(nodeBin, entry, buildDaemonPath(process.env.PATH ?? ""));
-  const current = existsSync8(p) ? readFileSync6(p, "utf-8") : null;
+  const current = existsSync9(p) ? readFileSync6(p, "utf-8") : null;
   const uid = process.getuid?.() ?? 0;
   const target = `gui/${uid}/${LABEL}`;
   const changed = current !== desired;
   const programChanged = current !== null && changed && !current.includes(programArgsBlock(nodeBin, entry));
   const parsedCurrent = current !== null ? parseProgramArgs(current) : null;
-  const foreignInstall = detectForeignInstall(parsedCurrent, entry, parsedCurrent !== null && existsSync8(parsedCurrent.daemonEntry));
+  const foreignInstall = detectForeignInstall(parsedCurrent, entry, parsedCurrent !== null && existsSync9(parsedCurrent.daemonEntry));
   return { plistPath: p, target, desired, current, changed, programChanged, foreignInstall };
 }
 function reconcilePlistAndService(drift) {
   if (drift.changed) {
-    mkdirSync4(dirname2(drift.plistPath), { recursive: true });
-    writeFileSync5(drift.plistPath, drift.desired);
+    mkdirSync5(dirname3(drift.plistPath), { recursive: true });
+    mkdirSync5(logsRoot(), { recursive: true });
+    writeFileSync6(drift.plistPath, drift.desired);
   }
   if (drift.programChanged) {
     try {
@@ -2742,6 +2810,17 @@ function applyDaemonDrift(drift) {
   reconcilePlistAndService(drift);
   execFileSync3("launchctl", ["kickstart", drift.target], { stdio: "ignore" });
 }
+function parseLaunchctlStderrPath(printOutput) {
+  const m = printOutput.match(/^\s*stderr path = (.+)$/m);
+  return m ? m[1].trim() : null;
+}
+function loadedDaemonLogPath(target) {
+  try {
+    return parseLaunchctlStderrPath(execFileSync3("launchctl", ["print", target], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }));
+  } catch {
+    return null;
+  }
+}
 function getDaemonPid(target) {
   try {
     const out = execFileSync3("launchctl", ["print", target], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
@@ -2856,7 +2935,9 @@ function reregisterDaemon(nodeBin = process.execPath, kickstartOpts = {}) {
   try {
     const drift = computeDaemonDrift(nodeBin);
     const pidBeforeReconcile = getDaemonPid(drift.target);
-    reconcilePlistAndService(drift);
+    const loadedLog = loadedDaemonLogPath(drift.target);
+    const logMoved = loadedLog !== null && loadedLog !== daemonLogPath();
+    reconcilePlistAndService({ ...drift, programChanged: drift.programChanged || logMoved });
     const result = forceKickstartAndVerify(drift.target, { ...kickstartOpts, pidBefore: pidBeforeReconcile });
     if (!result.restarted) {
       throw new Error(`daemon did not restart (pid before=${result.pidBefore ?? "none"}, after=${result.pidAfter ?? "none"}) \u2014 \`launchctl kickstart -k ${drift.target}\` ran but the pid never changed`);
@@ -2869,6 +2950,7 @@ function reregisterDaemon(nodeBin = process.execPath, kickstartOpts = {}) {
 var LABEL, AGENT_BINS, restartInFlight, OPERATOR_INITIATED_COMMANDS, READ_ONLY_CREW_SUBCOMMANDS, READ_ONLY_TOP_LEVEL_COMMANDS;
 var init_launchd = __esm({
   "packages/core/dist/launchd.js"() {
+    init_dist();
     LABEL = "com.squadrant.daemon";
     AGENT_BINS = ["cmux", "claude", "opencode", "codex", "gemini", "node"];
     restartInFlight = false;
@@ -3087,7 +3169,7 @@ var init_gate = __esm({
 });
 
 // packages/core/dist/daemon/liveness-registry.js
-import { writeFileSync as writeFileSync6, readFileSync as readFileSync7, renameSync as renameSync3 } from "fs";
+import { writeFileSync as writeFileSync7, readFileSync as readFileSync7, renameSync as renameSync3 } from "fs";
 var LivenessRegistry;
 var init_liveness_registry = __esm({
   "packages/core/dist/daemon/liveness-registry.js"() {
@@ -3107,7 +3189,7 @@ var init_liveness_registry = __esm({
           }
         });
         this.writeFile = opts.writeFile ?? ((p, c) => {
-          writeFileSync6(`${p}.tmp`, c);
+          writeFileSync7(`${p}.tmp`, c);
           renameSync3(`${p}.tmp`, p);
         });
       }
@@ -3157,10 +3239,9 @@ var init_liveness_registry = __esm({
 });
 
 // packages/core/dist/daemon/context.js
-import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { spawn as realSpawn } from "child_process";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
 function defaultIsPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -3170,27 +3251,27 @@ function defaultIsPidAlive(pid) {
   }
 }
 function buildContext(opts) {
-  const stateRoot = opts.stateRoot ?? join9(homedir6(), ".config", "squadrant", "state");
+  const stateRoot2 = opts.stateRoot ?? stateRoot();
   const sockPath = opts.sockPath ?? DAEMON_SOCK_PATH;
-  const store = createStore(stateRoot);
+  const store = createStore(stateRoot2);
   const bootedAt = Date.now();
   const config = loadConfig();
   const taskTimeoutMs = config.defaults.taskTimeoutMs;
   const takeoverNudgeHours = config.defaults.takeoverNudgeHours;
   const isPidAlive = opts.isPidAlive ?? defaultIsPidAlive;
   const spawn2 = opts.spawn ?? realSpawn;
-  const resultsDir = join9(stateRoot, "_results");
-  mkdirSync5(resultsDir, { recursive: true });
+  const resultsDir = join10(stateRoot2, "_results");
+  mkdirSync6(resultsDir, { recursive: true });
   const writeResult = (id, payload) => {
-    const p = join9(resultsDir, `${id}.txt`);
-    writeFileSync7(p, payload);
+    const p = join10(resultsDir, `${id}.txt`);
+    writeFileSync8(p, payload);
     return p;
   };
   const log = (m) => process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${m}
 `);
   return {
     opts,
-    stateRoot,
+    stateRoot: stateRoot2,
     sockPath,
     store,
     bootedAt,
@@ -3206,7 +3287,7 @@ function buildContext(opts) {
     inFlightHeadlessIds: /* @__PURE__ */ new Set(),
     activeHeadlessKills: /* @__PURE__ */ new Set(),
     livenessRegistry: (() => {
-      const r = new LivenessRegistry({ path: join9(stateRoot, "liveness.json") });
+      const r = new LivenessRegistry({ path: join10(stateRoot2, "liveness.json") });
       r.load();
       return r;
     })(),
@@ -3874,8 +3955,8 @@ var init_crew_routing = __esm({
 
 // packages/core/dist/permission-gate.js
 import { createHash } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 function isGateSession(env) {
   return Boolean(env.SQUADRANT_CREW_TASK_ID) || env[SIDE_SESSION_ENV] === "1" || env.SQUADRANT_ROLE === "captain";
 }
@@ -4097,7 +4178,7 @@ async function callClassifier(o) {
   }
 }
 function defaultGateCachePath() {
-  return join10(CONFIG_DIR, "state", "gate-cache.json");
+  return join11(CONFIG_DIR, "state", "gate-cache.json");
 }
 function gateCacheKey(toolName, cwd, toolPayload) {
   return createHash("sha256").update(`${toolName}
@@ -4261,8 +4342,8 @@ var init_permission_gate = __esm({
         const next = Object.fromEntries(entries);
         const tmp = `${this.path}.${process.pid}.${Date.now()}.tmp`;
         try {
-          mkdirSync6(dirname3(this.path), { recursive: true });
-          writeFileSync8(tmp, JSON.stringify(next), "utf-8");
+          mkdirSync7(dirname4(this.path), { recursive: true });
+          writeFileSync9(tmp, JSON.stringify(next), "utf-8");
           renameSync4(tmp, this.path);
         } catch {
           try {
@@ -4356,14 +4437,14 @@ var init_auto_gate = __esm({
 });
 
 // packages/core/dist/first-turn-spill.js
-import fs9 from "fs";
-import os4 from "os";
-import path10 from "path";
+import fs10 from "fs";
+import os5 from "os";
+import path11 from "path";
 function spillOversizedFirstTurn(text, id) {
   if (Buffer.byteLength(text, "utf8") <= FIRST_TURN_INLINE_MAX_BYTES)
     return text;
-  const spillFile = path10.join(os4.tmpdir(), `squadrant-task-${id}.md`);
-  fs9.writeFileSync(spillFile, text, "utf8");
+  const spillFile = path11.join(os5.tmpdir(), `squadrant-task-${id}.md`);
+  fs10.writeFileSync(spillFile, text, "utf8");
   return `Full task is at ${spillFile} \u2014 cat it and follow it exactly.`;
 }
 var FIRST_TURN_INLINE_MAX_BYTES;
@@ -4435,8 +4516,8 @@ import { exec as nodeExec } from "child_process";
 async function reapCrewChildren(taskId, graceMs = 2e3, execFn = nodeExec) {
   const marker = `SQUADRANT_CREW_TASK_ID=${taskId}`;
   try {
-    const stdout = await new Promise((resolve4, reject) => {
-      execFn("ps auxE", { maxBuffer: 64 * 1024 * 1024 }, (err, out) => err ? reject(err) : resolve4(out));
+    const stdout = await new Promise((resolve5, reject) => {
+      execFn("ps auxE", { maxBuffer: 64 * 1024 * 1024 }, (err, out) => err ? reject(err) : resolve5(out));
     });
     const pids = [];
     for (const line2 of stdout.split("\n").slice(1)) {
@@ -4470,14 +4551,14 @@ var init_crew_lifecycle = __esm({
 });
 
 // packages/core/dist/crew-spawn.js
-import fs10 from "fs";
-import os5 from "os";
-import path11 from "path";
+import fs11 from "fs";
+import os6 from "os";
+import path12 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function ensureSocksDir(dir = CC_SOCKS_DIR) {
-  fs10.mkdirSync(dir, { recursive: true, mode: 448 });
-  if ((fs10.statSync(dir).mode & 511) !== 448)
-    fs10.chmodSync(dir, 448);
+  fs11.mkdirSync(dir, { recursive: true, mode: 448 });
+  if ((fs11.statSync(dir).mode & 511) !== 448)
+    fs11.chmodSync(dir, 448);
 }
 async function pollFirstTurnConfirmedAt(getTaskRecord, project, id, scrapeSettled, cancel) {
   let scrapeSettledAt;
@@ -4499,14 +4580,14 @@ async function pollFirstTurnConfirmedAt(getTaskRecord, project, id, scrapeSettle
   }
 }
 function firstTrueOrBothFalse(a, b, deadlineMs) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let done = false;
     const finish = (ok2) => {
       if (done)
         return;
       done = true;
       clearTimeout(timer);
-      resolve4(ok2);
+      resolve5(ok2);
     };
     const timer = setTimeout(() => finish(false), deadlineMs);
     let settledFalseCount = 0;
@@ -4610,9 +4691,9 @@ async function runCrewSpawn(input, config, deps) {
   }) : proj.path;
   let firstTurnTask = input.task;
   if (input.taskFile && input.taskFile !== "-" && !input.shared) {
-    const absTaskFile = path11.resolve(input.taskFile);
-    const basename = path11.basename(absTaskFile);
-    fs10.copyFileSync(absTaskFile, path11.join(spawnCwd, basename));
+    const absTaskFile = path12.resolve(input.taskFile);
+    const basename = path12.basename(absTaskFile);
+    fs11.copyFileSync(absTaskFile, path12.join(spawnCwd, basename));
     firstTurnTask = `Read ./${basename} to get your task brief, then execute it.`;
   }
   const agentName = requestedAgent;
@@ -4626,8 +4707,8 @@ async function runCrewSpawn(input, config, deps) {
   assertBackendUsable({ backend, agent: agent.name, router: config.defaults.router });
   deps.onBackendResolved?.({ backend });
   if (agentName === "codex") {
-    const codexRoleFile = path11.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
-    const roleInstructions = fs10.existsSync(codexRoleFile) ? fs10.readFileSync(codexRoleFile, "utf8") : void 0;
+    const codexRoleFile = path12.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
+    const roleInstructions = fs11.existsSync(codexRoleFile) ? fs11.readFileSync(codexRoleFile, "utf8") : void 0;
     return runCodexInteractiveSpawn({
       project: input.project,
       task: input.task,
@@ -4643,7 +4724,7 @@ async function runCrewSpawn(input, config, deps) {
       sendCodexFirstTurn: deps.sendCodexFirstTurn
     });
   }
-  const promptFile = path11.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
+  const promptFile = path12.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
   const interactive = agent.name === "claude" || agent.name === "opencode";
   const crewRole = config.defaults.roles?.crew;
   const configModel = crewRole && crewRole.agent === agent.name ? crewRole.model : void 0;
@@ -4669,7 +4750,7 @@ async function runCrewSpawn(input, config, deps) {
       }
     }
     ensureSocksDir();
-    const messagingSocketPath = path11.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
+    const messagingSocketPath = path12.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
     const rec = await deps.dispatchCrew({
       provider: "claude",
       mode: "interactive",
@@ -4680,7 +4761,7 @@ async function runCrewSpawn(input, config, deps) {
       messagingSocketPath
     });
     const routerSettingsPath = Object.keys(routerEnv).length > 0 ? deps.writeRouterSettings({
-      stateRoot: STATE_ROOT,
+      stateRoot: stateRoot(),
       project: input.project,
       taskId: rec.id,
       env: mergeClaudeEnvRouterSettings(routerEnv, config.defaults.claudeEnv)
@@ -4777,7 +4858,7 @@ ${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen) : Promise.r
 `);
     }
     const opencodeConfigPath = deps.writeOpencodeConfig({
-      stateRoot: STATE_ROOT,
+      stateRoot: stateRoot(),
       project: input.project,
       taskId: rec.id,
       // CP3 opt-in: --approval gates bash so the captain approves shell commands.
@@ -4947,7 +5028,7 @@ function buildRecoveryHint(sessId, provider, worktreeCwd) {
     return "";
   if (provider === "claude") {
     const escaped = worktreeCwd.replace(/[^a-zA-Z0-9]/g, "-");
-    const transcriptPath = path11.join(os5.homedir(), ".claude", "projects", escaped, `${sessId}.jsonl`);
+    const transcriptPath = path12.join(os6.homedir(), ".claude", "projects", escaped, `${sessId}.jsonl`);
     return `
 transcript: ${transcriptPath}
 resume:     claude --resume ${sessId}   (run from the worktree path above)
@@ -5042,7 +5123,7 @@ async function runCrewList(project, runtime, workspaceId) {
     surfaceId: c.surfaceId
   }));
 }
-var CC_SOCKS_DIR, TEMPLATES_DIR, STATE_ROOT, FIRST_TURN_HOOK_CONFIRM_GRACE_MS, FIRST_TURN_HOOK_CONFIRM_MAX_MS, FIRST_TURN_HOOK_POLL_INTERVAL_MS, CLOSE_LOOKUP_RETRIES, CLOSE_LOOKUP_RETRY_DELAY_MS;
+var CC_SOCKS_DIR, TEMPLATES_DIR, FIRST_TURN_HOOK_CONFIRM_GRACE_MS, FIRST_TURN_HOOK_CONFIRM_MAX_MS, FIRST_TURN_HOOK_POLL_INTERVAL_MS, CLOSE_LOOKUP_RETRIES, CLOSE_LOOKUP_RETRY_DELAY_MS;
 var init_crew_spawn = __esm({
   "packages/core/dist/crew-spawn.js"() {
     init_control_channel();
@@ -5056,8 +5137,7 @@ var init_crew_spawn = __esm({
     init_crew_protocol();
     init_crew_lifecycle();
     CC_SOCKS_DIR = "/tmp/cc-socks";
-    TEMPLATES_DIR = path11.join(os5.homedir(), ".config", "squadrant", "templates");
-    STATE_ROOT = path11.join(os5.homedir(), ".config", "squadrant", "state");
+    TEMPLATES_DIR = path12.join(os6.homedir(), ".config", "squadrant", "templates");
     FIRST_TURN_HOOK_CONFIRM_GRACE_MS = 15e3;
     FIRST_TURN_HOOK_CONFIRM_MAX_MS = 18e4;
     FIRST_TURN_HOOK_POLL_INTERVAL_MS = 2e3;
@@ -5067,12 +5147,12 @@ var init_crew_spawn = __esm({
 });
 
 // packages/core/dist/captain-channel.js
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function captainSocketPath(project, socksDir = CC_SOCKS_DIR) {
   if (!/^[A-Za-z0-9._-]+$/.test(project)) {
     throw new Error(`captain-channel: project name '${project}' is not a safe socket filename`);
   }
-  return join11(socksDir, `squadrant-captain-${project}.sock`);
+  return join12(socksDir, `squadrant-captain-${project}.sock`);
 }
 async function deliverToCaptain(project, text, deps) {
   if (deps.mode === "off")
@@ -5102,23 +5182,23 @@ var init_captain_channel = __esm({
 });
 
 // packages/core/dist/captain-record.js
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync9, realpathSync, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname4, join as join12 } from "path";
-function captainRecordPath(stateRoot, project) {
-  return join12(stateRoot, project, "captain.json");
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync9, realpathSync, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+function captainRecordPath(stateRoot2, project) {
+  return join13(stateRoot2, project, "captain.json");
 }
-function readCaptainAddress(stateRoot, project) {
+function readCaptainAddress(stateRoot2, project) {
   try {
-    const parsed = JSON.parse(readFileSync9(captainRecordPath(stateRoot, project), "utf-8"));
+    const parsed = JSON.parse(readFileSync9(captainRecordPath(stateRoot2, project), "utf-8"));
     return parsed && typeof parsed.agent === "string" ? parsed : null;
   } catch {
     return null;
   }
 }
-function writeCaptainAddress(stateRoot, project, addr) {
-  const p = captainRecordPath(stateRoot, project);
-  mkdirSync7(dirname4(p), { recursive: true });
-  writeFileSync9(p, JSON.stringify(addr, null, 2) + "\n");
+function writeCaptainAddress(stateRoot2, project, addr) {
+  const p = captainRecordPath(stateRoot2, project);
+  mkdirSync8(dirname5(p), { recursive: true });
+  writeFileSync10(p, JSON.stringify(addr, null, 2) + "\n");
 }
 function realpathOrSelf(p) {
   try {
@@ -5141,11 +5221,11 @@ var init_captain_record = __esm({
 // packages/core/dist/opencode-session.js
 import { execFileSync as execFileSync4 } from "child_process";
 async function listSessions(port, fetchImpl = fetch, timeoutMs = 5e3) {
-  for (const path43 of ["/session", "/api/session"]) {
+  for (const path44 of ["/session", "/api/session"]) {
     const ac = new AbortController();
     const t = setTimeout(() => ac.abort(), timeoutMs);
     try {
-      const res = await fetchImpl(`http://127.0.0.1:${port}${path43}`, { signal: ac.signal });
+      const res = await fetchImpl(`http://127.0.0.1:${port}${path44}`, { signal: ac.signal });
       if (!res.ok)
         continue;
       const rows = await res.json();
@@ -5276,19 +5356,19 @@ async function reresolveOpencodeAddress(rec) {
     return null;
   return { port, sessionId };
 }
-async function healStaleOpencodeAddress(stateRoot, project, log, logPrefix) {
-  const rec = readCaptainAddress(stateRoot, project);
+async function healStaleOpencodeAddress(stateRoot2, project, log, logPrefix) {
+  const rec = readCaptainAddress(stateRoot2, project);
   if (!rec)
     return false;
   const resolved = await reresolveOpencodeAddress(rec);
   if (!resolved)
     return false;
-  const current = readCaptainAddress(stateRoot, project);
+  const current = readCaptainAddress(stateRoot2, project);
   if (!current || current.launchedAt !== rec.launchedAt) {
     log(`captain-channel ${project}: skipped stale-address heal \u2014 a newer launch record won the race`);
     return false;
   }
-  writeCaptainAddress(stateRoot, project, { ...current, port: resolved.port, sessionId: resolved.sessionId });
+  writeCaptainAddress(stateRoot2, project, { ...current, port: resolved.port, sessionId: resolved.sessionId });
   log(`captain-channel ${project}: ${logPrefix} \u2192 port ${resolved.port}`);
   return true;
 }
@@ -5384,7 +5464,7 @@ async function runLivenessTick(deps) {
   }
 }
 function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
-  const { stateRoot, store, log, livenessRegistry, isPidAlive, opts, telegramBridge } = ctx;
+  const { stateRoot: stateRoot2, store, log, livenessRegistry, isPidAlive, opts, telegramBridge } = ctx;
   const surfaceProbe = isSurfaceAlive ?? (async () => "unknown");
   const notifyFault = ctx.notifyFault ?? (() => {
   });
@@ -5395,7 +5475,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
     }
     try {
       await appendToMailbox({
-        stateRoot,
+        stateRoot: stateRoot2,
         project: args.project,
         taskRecord: args.record,
         event: args.event,
@@ -5474,7 +5554,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
         surface = await resolveCaptainSurface();
         if (!surface)
           continue;
-        const cursor = await readCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER });
+        const cursor = await readCursor({ stateRoot: stateRoot2, project, subscriber: CURSOR_SUBSCRIBER });
         const lastAcked = cursor?.lastAckedSeq ?? 0;
         let d = deliveries.get(project);
         if (!d) {
@@ -5485,7 +5565,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
           deliveries.set(project, d);
         }
         const pending = [];
-        for await (const entry of readFromCursor({ stateRoot, project, fromSeq: lastAcked + 1 }))
+        for await (const entry of readFromCursor({ stateRoot: stateRoot2, project, fromSeq: lastAcked + 1 }))
           pending.push(entry);
         const decisions = coalesceBacklog(pending, {
           now: Date.now(),
@@ -5498,7 +5578,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
               const isExemptMessage = entry.kind === "captain.message" && entry.payload?.source !== "daemon";
               if (!isExemptMessage) {
                 log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-skipped`);
-                await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+                await writeCursor({ stateRoot: stateRoot2, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
                 continue;
               }
               if (logStale)
@@ -5511,7 +5591,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
           const decision = decisions[i];
           if (decision.action === "skip") {
             log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=coalesced reason=${decision.reason}`);
-            await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+            await writeCursor({ stateRoot: stateRoot2, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
             continue;
           }
           const result = await d.deliver(decision.entry, async (text, sendOpts) => {
@@ -5527,7 +5607,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
                 log(`captain-channel ${project}: threw, falling back to pane \u2014 ${e.message}`);
               }
               if (agent === "opencode" && mode !== "off") {
-                const healed = await healStaleOpencodeAddress(stateRoot, project, log, "re-resolved opencode address");
+                const healed = await healStaleOpencodeAddress(stateRoot2, project, log, "re-resolved opencode address");
                 if (healed) {
                   try {
                     const retry = await deliverToCaptain(project, text, { channel: picked, mode, log });
@@ -5564,7 +5644,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
           });
           if ("delivered" in result) {
             log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=delivered`);
-            await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+            await writeCursor({ stateRoot: stateRoot2, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
             lastDeferred.delete(project);
             projectBackoff.delete(project);
           } else {
@@ -5591,7 +5671,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
           log(`delivery stuck project=${project} deferCount=${maxDeferCount} reason=${reason ?? "unknown"}`);
           const text = STUCK_ALERT_TEXT[reason ?? "unknown"](maxDeferCount);
           try {
-            await appendCaptainMessage({ stateRoot, project, text, source: "daemon" });
+            await appendCaptainMessage({ stateRoot: stateRoot2, project, text, source: "daemon" });
           } catch (e) {
             log(`delivery stuck alert failed project=${project}: ${e.message}`);
           }
@@ -5766,21 +5846,21 @@ var init_server = __esm({
 });
 
 // packages/core/dist/daemon/exit-marker.js
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync9 } from "fs";
-import { join as join13 } from "path";
-function exitMarkerPath(stateRoot) {
-  return join13(stateRoot, "exit-marker.json");
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync11, unlinkSync as unlinkSync4, existsSync as existsSync10 } from "fs";
+import { join as join14 } from "path";
+function exitMarkerPath(stateRoot2) {
+  return join14(stateRoot2, "exit-marker.json");
 }
-function writeExitMarker(stateRoot, marker, log) {
+function writeExitMarker(stateRoot2, marker, log) {
   try {
-    writeFileSync10(exitMarkerPath(stateRoot), JSON.stringify(marker));
+    writeFileSync11(exitMarkerPath(stateRoot2), JSON.stringify(marker));
   } catch (e) {
     log(`exit marker write failed: ${e.message}`);
   }
 }
-function consumeExitMarker(stateRoot, now = Date.now) {
-  const p = exitMarkerPath(stateRoot);
-  if (!existsSync9(p))
+function consumeExitMarker(stateRoot2, now = Date.now) {
+  const p = exitMarkerPath(stateRoot2);
+  if (!existsSync10(p))
     return { marker: null };
   let marker = null;
   try {
@@ -5797,26 +5877,26 @@ function consumeExitMarker(stateRoot, now = Date.now) {
   const gapMs = Math.max(0, now() - new Date(marker.ts).getTime());
   return { marker, gapMs };
 }
-function runningMarkerPath(stateRoot) {
-  return join13(stateRoot, "running-marker.json");
+function runningMarkerPath(stateRoot2) {
+  return join14(stateRoot2, "running-marker.json");
 }
-function writeRunningMarker(stateRoot, marker, log) {
+function writeRunningMarker(stateRoot2, marker, log) {
   try {
-    writeFileSync10(runningMarkerPath(stateRoot), JSON.stringify(marker));
+    writeFileSync11(runningMarkerPath(stateRoot2), JSON.stringify(marker));
   } catch (e) {
     log(`running marker write failed: ${e.message}`);
   }
 }
-function readRunningMarker(stateRoot) {
+function readRunningMarker(stateRoot2) {
   try {
-    return JSON.parse(readFileSync10(runningMarkerPath(stateRoot), "utf-8"));
+    return JSON.parse(readFileSync10(runningMarkerPath(stateRoot2), "utf-8"));
   } catch {
     return null;
   }
 }
-function removeRunningMarker(stateRoot, log) {
+function removeRunningMarker(stateRoot2, log) {
   try {
-    unlinkSync4(runningMarkerPath(stateRoot));
+    unlinkSync4(runningMarkerPath(stateRoot2));
   } catch (e) {
     if (e.code !== "ENOENT")
       log(`running marker remove failed: ${e.message}`);
@@ -5829,8 +5909,8 @@ var init_exit_marker = __esm({
 
 // packages/core/dist/daemon/snapshot-gather.js
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join14 } from "path";
-import { statSync as statSync3, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync3, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
+import { statSync as statSync3, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
 function distBuiltAt() {
   try {
     return statSync3(SELF_PATH).mtimeMs;
@@ -5838,10 +5918,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path43, now, windowMs) {
+function gatherLogStats(path44, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync3(path43).size;
+    sizeBytes = statSync3(path44).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -5852,7 +5932,7 @@ function gatherLogStats(path43, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path43, "r");
+    const fd = openSync2(path44, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -5878,14 +5958,14 @@ function gatherLogStats(path43, now, windowMs) {
   }
   return { errorCount, sizeBytes, windowMs };
 }
-function gatherStoreStats(store, stateRoot, project) {
+function gatherStoreStats(store, stateRoot2, project) {
   const byState = {};
   for (const r of store.list(project))
     byState[r.state] = (byState[r.state] ?? 0) + 1;
   let corruptCount = 0;
-  const dir = join14(stateRoot, project);
+  const dir = join15(stateRoot2, project);
   try {
-    for (const n of readdirSync3(dir)) {
+    for (const n of readdirSync4(dir)) {
       if (n.includes(".corrupt.")) {
         corruptCount++;
         continue;
@@ -5893,7 +5973,7 @@ function gatherStoreStats(store, stateRoot, project) {
       if (!n.endsWith(".json"))
         continue;
       try {
-        JSON.parse(readFileSync11(join14(dir, n), "utf-8"));
+        JSON.parse(readFileSync11(join15(dir, n), "utf-8"));
       } catch {
         corruptCount++;
       }
@@ -5906,9 +5986,9 @@ function gatherResults(resultsDir) {
   let fileCount = 0;
   let totalBytes = 0;
   try {
-    for (const n of readdirSync3(resultsDir)) {
+    for (const n of readdirSync4(resultsDir)) {
       try {
-        const s = statSync3(join14(resultsDir, n));
+        const s = statSync3(join15(resultsDir, n));
         if (s.isFile()) {
           fileCount++;
           totalBytes += s.size;
@@ -5928,10 +6008,10 @@ var init_snapshot_gather = __esm({
 });
 
 // packages/core/dist/daemon/start.js
-import { join as join15, dirname as dirname5 } from "path";
+import { join as join16 } from "path";
 import { readdir } from "fs/promises";
 function startDaemon(ctx, opts, pkgVersion) {
-  const { stateRoot, store, log, isPidAlive, resultsDir, taskTimeoutMs, inFlightHeadlessIds, activeHeadlessKills, broadcast, cancelPromotionsFor } = ctx;
+  const { stateRoot: stateRoot2, store, log, isPidAlive, resultsDir, taskTimeoutMs, inFlightHeadlessIds, activeHeadlessKills, broadcast, cancelPromotionsFor } = ctx;
   const { daemonCmux } = ctx;
   const probes = createProbes(ctx);
   const surfaceProbe = buildSurfaceProbe(ctx, probes, daemonCmux);
@@ -6005,14 +6085,14 @@ function startDaemon(ctx, opts, pkgVersion) {
     return out;
   }
   async function gatherSnapshotInputs(now) {
-    const logPath2 = join15(dirname5(stateRoot), "squadrantd.log");
+    const logPath2 = stateRoot2 === stateRoot() ? resolveReadPath(daemonLogPath(), legacyDaemonLogPath()) : join16(stateRoot2, "logs", "squadrantd.log");
     const tier2Projects = opts.registeredProjects ?? Object.keys(loadConfig().projects);
     const projects = await Promise.all(tier2Projects.map(async (project) => {
-      const cursor = await readCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER2 });
-      const storeStats = gatherStoreStats(store, stateRoot, project);
+      const cursor = await readCursor({ stateRoot: stateRoot2, project, subscriber: CURSOR_SUBSCRIBER2 });
+      const storeStats = gatherStoreStats(store, stateRoot2, project);
       return {
         project,
-        mailbox: await mailboxStats(stateRoot, project),
+        mailbox: await mailboxStats(stateRoot2, project),
         lastAckedSeq: cursor?.lastAckedSeq ?? 0,
         storeByState: storeStats.byState,
         corruptCount: storeStats.corruptCount,
@@ -6101,18 +6181,18 @@ function startDaemon(ctx, opts, pkgVersion) {
     }
   })();
   const server = createServer2(ctx, { buildHealth, gatherSnapshotInputs, cancelPromotionsFor, broadcast });
-  log(`boot pid=${process.pid} version=${pkgVersion} socket=${ctx.sockPath} stateRoot=${stateRoot}`);
+  log(`boot pid=${process.pid} version=${pkgVersion} socket=${ctx.sockPath} stateRoot=${stateRoot2}`);
   const bootTs = (/* @__PURE__ */ new Date()).toISOString();
   {
     const sendDownAlert = (startTs, endTs, minutes, reasonText) => {
       const text = formatDownAlertText({ startTs, endTs, minutes, reasonText });
       const alertProjects = opts.registeredProjects ?? Object.keys(loadConfig().projects);
       for (const project of alertProjects) {
-        appendCaptainMessage({ stateRoot, project, text, source: "daemon" }).catch((e) => log(`boot-gap alert failed project=${project}: ${e.message}`));
+        appendCaptainMessage({ stateRoot: stateRoot2, project, text, source: "daemon" }).catch((e) => log(`boot-gap alert failed project=${project}: ${e.message}`));
       }
     };
-    const { marker, gapMs } = consumeExitMarker(stateRoot);
-    const prevRunning = readRunningMarker(stateRoot);
+    const { marker, gapMs } = consumeExitMarker(stateRoot2);
+    const prevRunning = readRunningMarker(stateRoot2);
     if (marker) {
       log(`previous exit ts=${marker.ts} reason=${marker.reason} gap=${((gapMs ?? 0) / 1e3).toFixed(1)}s`);
       if ((gapMs ?? 0) > 6e4)
@@ -6127,7 +6207,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     } else {
       log("previous exit: none (clean or first boot)");
     }
-    writeRunningMarker(stateRoot, { pid: process.pid, bootTs, lastHeartbeatTs: bootTs }, log);
+    writeRunningMarker(stateRoot2, { pid: process.pid, bootTs, lastHeartbeatTs: bootTs }, log);
   }
   let deliveryTick = initialDeliveryTick;
   let probeTick;
@@ -6171,7 +6251,7 @@ function startDaemon(ctx, opts, pkgVersion) {
   let rotationTimer;
   let rotationTick;
   if (rotationInterval > 0) {
-    const inboxPath = join15(stateRoot, "inbox");
+    const inboxPath = join16(stateRoot2, "inbox");
     rotationTick = async () => {
       try {
         let entries;
@@ -6182,12 +6262,12 @@ function startDaemon(ctx, opts, pkgVersion) {
         }
         const projects = new Set(entries.filter((e) => e.endsWith(".log")).map((e) => e.slice(0, -".log".length)));
         for (const project of projects)
-          await rotateIfNeeded({ stateRoot, project, ...mboxCfg });
+          await rotateIfNeeded({ stateRoot: stateRoot2, project, ...mboxCfg });
         await opts.knowledgeTick?.();
       } catch (e) {
         log(`rotation timer error: ${e.message}`);
       } finally {
-        writeRunningMarker(stateRoot, { pid: process.pid, bootTs, lastHeartbeatTs: (/* @__PURE__ */ new Date()).toISOString() }, log);
+        writeRunningMarker(stateRoot2, { pid: process.pid, bootTs, lastHeartbeatTs: (/* @__PURE__ */ new Date()).toISOString() }, log);
       }
     };
     rotationTimer = setInterval(() => {
@@ -6201,8 +6281,8 @@ function startDaemon(ctx, opts, pkgVersion) {
       const uptimeMs = Math.round(process.uptime() * 1e3);
       const inFlight = inFlightDelivery();
       log(`exit pid=${process.pid} reason=${reason} ppid=${ppid} launchd=${ppid === 1} uptimeMs=${uptimeMs} inFlightDelivery=${inFlight ? `${inFlight.project}#${inFlight.seq}(defers=${inFlight.deferCount})` : "none"}`);
-      writeExitMarker(stateRoot, { ts: (/* @__PURE__ */ new Date()).toISOString(), pid: process.pid, reason, ppid, uptimeMs, inFlightDelivery: inFlight }, log);
-      removeRunningMarker(stateRoot, log);
+      writeExitMarker(stateRoot2, { ts: (/* @__PURE__ */ new Date()).toISOString(), pid: process.pid, reason, ppid, uptimeMs, inFlightDelivery: inFlight }, log);
+      removeRunningMarker(stateRoot2, log);
       if (deliveryTimer)
         clearInterval(deliveryTimer);
       if (probeTimer)
@@ -6229,9 +6309,9 @@ function startDaemon(ctx, opts, pkgVersion) {
         await ctx.routerService?.stop();
       } catch {
       }
-      return new Promise((resolve4) => server.close(() => {
+      return new Promise((resolve5) => server.close(() => {
         log(`exit-complete pid=${process.pid}`);
-        resolve4();
+        resolve5();
       }));
     },
     tickDelivery: deliveryTick,
@@ -6260,11 +6340,12 @@ var init_start = __esm({
 
 // packages/core/dist/session-freshness.js
 import crypto from "crypto";
-import fs11 from "fs";
-import path12 from "path";
-function loadSessions(sessionsPath) {
+import fs12 from "fs";
+import path13 from "path";
+function loadSessions(sessionsPath, legacyPath) {
   try {
-    return JSON.parse(readConfigFileSync(sessionsPath));
+    const readPath = legacyPath ? resolveReadPath(sessionsPath, legacyPath) : sessionsPath;
+    return JSON.parse(readConfigFileSync(readPath));
   } catch {
     return { workspaces: {} };
   }
@@ -6274,26 +6355,26 @@ function saveSessions(sessionsPath, sessions) {
 }
 function computeTemplateHash(role, templatesDir) {
   const hash = crypto.createHash("sha256");
-  const roleFile = path12.join(templatesDir, `${role}.claude.md`);
-  const legacyRoleFile = path12.join(templatesDir, `${role}.CLAUDE.md`);
-  if (fs11.existsSync(roleFile)) {
-    hash.update(fs11.readFileSync(roleFile, "utf-8"));
-  } else if (fs11.existsSync(legacyRoleFile)) {
-    hash.update(fs11.readFileSync(legacyRoleFile, "utf-8"));
+  const roleFile = path13.join(templatesDir, `${role}.claude.md`);
+  const legacyRoleFile = path13.join(templatesDir, `${role}.CLAUDE.md`);
+  if (fs12.existsSync(roleFile)) {
+    hash.update(fs12.readFileSync(roleFile, "utf-8"));
+  } else if (fs12.existsSync(legacyRoleFile)) {
+    hash.update(fs12.readFileSync(legacyRoleFile, "utf-8"));
   }
-  const pluginSkillsDir = path12.join(templatesDir, "..", "plugin", "skills");
-  if (fs11.existsSync(pluginSkillsDir)) {
-    for (const skill of fs11.readdirSync(pluginSkillsDir).sort()) {
-      const skillFile = path12.join(pluginSkillsDir, skill, "SKILL.md");
-      if (fs11.existsSync(skillFile)) {
-        hash.update(fs11.readFileSync(skillFile, "utf-8"));
+  const pluginSkillsDir = path13.join(templatesDir, "..", "plugin", "skills");
+  if (fs12.existsSync(pluginSkillsDir)) {
+    for (const skill of fs12.readdirSync(pluginSkillsDir).sort()) {
+      const skillFile = path13.join(pluginSkillsDir, skill, "SKILL.md");
+      if (fs12.existsSync(skillFile)) {
+        hash.update(fs12.readFileSync(skillFile, "utf-8"));
       }
     }
   }
   return hash.digest("hex").slice(0, 16);
 }
 function shouldStartFresh(workspaceName, role, opts) {
-  const sessions = loadSessions(opts.sessionsPath);
+  const sessions = loadSessions(opts.sessionsPath, opts.legacySessionsPath);
   const record = sessions.workspaces[workspaceName];
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const currentHash = computeTemplateHash(role, opts.templatesDir);
@@ -6309,7 +6390,7 @@ function shouldStartFresh(workspaceName, role, opts) {
   return { fresh: false };
 }
 function recordSession(workspaceName, role, opts) {
-  const sessions = loadSessions(opts.sessionsPath);
+  const sessions = loadSessions(opts.sessionsPath, opts.legacySessionsPath);
   sessions.workspaces[workspaceName] = {
     lastLaunched: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
     templateHash: computeTemplateHash(role, opts.templatesDir)
@@ -6523,7 +6604,7 @@ function createIsCaptainAlive(sock) {
   };
 }
 function createLaunch(cliBin, log) {
-  return (project) => new Promise((resolve4, reject) => {
+  return (project) => new Promise((resolve5, reject) => {
     execFile(process.execPath, [cliBin, "launch", project, "--headless"], { timeout: 3e4 }, (err, stdout, stderr) => {
       const output = capOutput(stdout ?? "", stderr ?? "");
       if (err) {
@@ -6533,7 +6614,7 @@ function createLaunch(cliBin, log) {
       }
       if (output !== "(no output)")
         log?.(`launch ${project}: ${output}`);
-      resolve4();
+      resolve5();
     });
   });
 }
@@ -6670,16 +6751,16 @@ var init_format = __esm({
 });
 
 // packages/core/dist/telegram/state.js
-import path13 from "path";
-function statePath(stateRoot) {
-  return path13.join(stateRoot, "telegram-state.json");
+import path14 from "path";
+function statePath(stateRoot2) {
+  return path14.join(stateRoot2, "telegram-state.json");
 }
 function topicKey(project, scope = "project") {
   return `${project}::${scope}`;
 }
-function loadState(stateRoot) {
+function loadState(stateRoot2) {
   try {
-    const raw = readConfigFileSync(statePath(stateRoot));
+    const raw = readConfigFileSync(statePath(stateRoot2));
     const data = JSON.parse(raw);
     const result = {
       offset: typeof data.offset === "number" ? data.offset : 0,
@@ -6695,16 +6776,16 @@ function loadState(stateRoot) {
     return { offset: 0, topics: {}, notify: {} };
   }
 }
-function saveState(stateRoot, s) {
-  writeConfigFileSync(statePath(stateRoot), JSON.stringify(s, null, 2) + "\n");
+function saveState(stateRoot2, s) {
+  writeConfigFileSync(statePath(stateRoot2), JSON.stringify(s, null, 2) + "\n");
 }
-function setTopic(stateRoot, project, topicId, scope = "project") {
-  const s = loadState(stateRoot);
+function setTopic(stateRoot2, project, topicId, scope = "project") {
+  const s = loadState(stateRoot2);
   s.topics[topicKey(project, scope)] = topicId;
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function pruneTopics(stateRoot, keep) {
-  const s = loadState(stateRoot);
+function pruneTopics(stateRoot2, keep) {
+  const s = loadState(stateRoot2);
   const removed = Object.keys(s.topics).filter((key) => {
     const sep3 = key.indexOf("::");
     return !keep(sep3 === -1 ? key : key.slice(0, sep3));
@@ -6713,60 +6794,60 @@ function pruneTopics(stateRoot, keep) {
     return [];
   for (const key of removed)
     delete s.topics[key];
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
   return removed;
 }
-function isNotifyActive(stateRoot, project) {
-  return loadState(stateRoot).notify[project] === true;
+function isNotifyActive(stateRoot2, project) {
+  return loadState(stateRoot2).notify[project] === true;
 }
-function setLastUserId(stateRoot, id) {
-  const s = loadState(stateRoot);
+function setLastUserId(stateRoot2, id) {
+  const s = loadState(stateRoot2);
   s.lastUserId = id;
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function setNotify(stateRoot, project, active) {
-  const s = loadState(stateRoot);
+function setNotify(stateRoot2, project, active) {
+  const s = loadState(stateRoot2);
   s.notify[project] = active;
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function loadPending(stateRoot) {
-  return loadState(stateRoot).pending ?? {};
+function loadPending(stateRoot2) {
+  return loadState(stateRoot2).pending ?? {};
 }
-function setPending(stateRoot, project, p) {
-  const s = loadState(stateRoot);
+function setPending(stateRoot2, project, p) {
+  const s = loadState(stateRoot2);
   s.pending = { ...s.pending ?? {}, [project]: p };
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function clearPending(stateRoot, project) {
-  const s = loadState(stateRoot);
+function clearPending(stateRoot2, project) {
+  const s = loadState(stateRoot2);
   if (!s.pending || !(project in s.pending))
     return;
   delete s.pending[project];
   if (Object.keys(s.pending).length === 0)
     delete s.pending;
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function markPendingWarned(stateRoot, project, at) {
-  const s = loadState(stateRoot);
+function markPendingWarned(stateRoot2, project, at) {
+  const s = loadState(stateRoot2);
   const p = s.pending?.[project];
   if (!p)
     return;
   s.pending[project] = { ...p, warnedAt: at };
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
 }
-function notePaneScreen(stateRoot, project, hash, at) {
-  const s = loadState(stateRoot);
+function notePaneScreen(stateRoot2, project, hash, at) {
+  const s = loadState(stateRoot2);
   const p = s.pending?.[project];
   if (!p)
     return void 0;
   if (p.paneHash === hash && p.paneChangedAt !== void 0)
     return at - p.paneChangedAt;
   s.pending[project] = { ...p, paneHash: hash, paneChangedAt: at };
-  saveState(stateRoot, s);
+  saveState(stateRoot2, s);
   return void 0;
 }
-function findProjectByThread(stateRoot, threadId) {
-  const s = loadState(stateRoot);
+function findProjectByThread(stateRoot2, threadId) {
+  const s = loadState(stateRoot2);
   for (const [key, id] of Object.entries(s.topics)) {
     if (id !== threadId)
       continue;
@@ -6888,7 +6969,7 @@ function formatWatchdogWarning(project, read, minutes) {
   }
 }
 function createInboundLifecycle(opts) {
-  const { stateRoot, cfg, sendChatAction, sendReply, readPane, log } = opts;
+  const { stateRoot: stateRoot2, cfg, sendChatAction, sendReply, readPane, log } = opts;
   const now = opts.now ?? Date.now;
   const schedule = opts.schedule ?? defaultSchedule;
   const typingMs = opts.typingMs ?? TYPING_KEEPALIVE_MS;
@@ -6904,7 +6985,7 @@ function createInboundLifecycle(opts) {
     const tick = () => {
       if (!running || !active.has(project))
         return;
-      const p = loadPending(stateRoot)[project];
+      const p = loadPending(stateRoot2)[project];
       if (!p) {
         active.delete(project);
         return;
@@ -6918,7 +6999,7 @@ function createInboundLifecycle(opts) {
     schedule(tick, typingMs);
   }
   async function warn(project, threadId) {
-    markPendingWarned(stateRoot, project, now());
+    markPendingWarned(stateRoot2, project, now());
     let read = { status: "unreadable" };
     try {
       if (readPane)
@@ -6935,7 +7016,7 @@ function createInboundLifecycle(opts) {
   return {
     start() {
       running = true;
-      for (const [project, p] of Object.entries(loadPending(stateRoot))) {
+      for (const [project, p] of Object.entries(loadPending(stateRoot2))) {
         void (async () => {
           let read = { status: "unreadable" };
           try {
@@ -6944,11 +7025,11 @@ function createInboundLifecycle(opts) {
           } catch (e) {
             log(`telegram resume pane read failed project=${project}: ${e.message}`);
           }
-          const still = loadPending(stateRoot)[project];
+          const still = loadPending(stateRoot2)[project];
           if (!still || still.startedAt !== p.startedAt)
             return;
           if (read.status === "no-session") {
-            clearPending(stateRoot, project);
+            clearPending(stateRoot2, project);
             log(`telegram typing lifecycle cleared for ${project}: captain session gone on boot`);
             return;
           }
@@ -6963,13 +7044,13 @@ function createInboundLifecycle(opts) {
       active.clear();
     },
     begin(project, threadId) {
-      setPending(stateRoot, project, { threadId, startedAt: now() });
+      setPending(stateRoot2, project, { threadId, startedAt: now() });
       issue(project, threadId);
       if (running && !active.has(project))
         drain(project);
     },
     pending() {
-      return loadPending(stateRoot);
+      return loadPending(stateRoot2);
     }
   };
 }
@@ -7164,9 +7245,9 @@ var init_tiers = __esm({
 });
 
 // packages/core/dist/telegram/bridge.js
-import fs12 from "fs";
-import os6 from "os";
-import path14 from "path";
+import fs13 from "fs";
+import os7 from "os";
+import path15 from "path";
 import crypto2 from "crypto";
 function formatInboundReceipt(project, outcome) {
   if (!outcome)
@@ -7185,7 +7266,7 @@ function formatInboundReceipt(project, outcome) {
 }
 function telegramPollLockPath(token) {
   const hash = crypto2.createHash("sha256").update(token).digest("hex").slice(0, 16);
-  return path14.join(os6.tmpdir(), `squadrant-telegram-poll-${hash}.lock`);
+  return path15.join(os7.tmpdir(), `squadrant-telegram-poll-${hash}.lock`);
 }
 function pidAlive(pid) {
   try {
@@ -7199,9 +7280,9 @@ function lockIsHeld(file) {
   let pid;
   let ageMs;
   try {
-    const parsed = Number.parseInt(fs12.readFileSync(file, "utf8").trim(), 10);
+    const parsed = Number.parseInt(fs13.readFileSync(file, "utf8").trim(), 10);
     pid = Number.isFinite(parsed) ? parsed : void 0;
-    ageMs = Date.now() - fs12.statSync(file).mtimeMs;
+    ageMs = Date.now() - fs13.statSync(file).mtimeMs;
   } catch {
     return false;
   }
@@ -7213,12 +7294,12 @@ function acquirePollLock(token) {
   const file = telegramPollLockPath(token);
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs12.openSync(file, "wx");
-      fs12.writeSync(fd, String(process.pid));
-      fs12.closeSync(fd);
+      const fd = fs13.openSync(file, "wx");
+      fs13.writeSync(fd, String(process.pid));
+      fs13.closeSync(fd);
       return () => {
         try {
-          fs12.unlinkSync(file);
+          fs13.unlinkSync(file);
         } catch {
         }
       };
@@ -7227,7 +7308,7 @@ function acquirePollLock(token) {
         return null;
       if (attempt === 0 && !lockIsHeld(file)) {
         try {
-          fs12.unlinkSync(file);
+          fs13.unlinkSync(file);
         } catch {
         }
         continue;
@@ -7246,7 +7327,7 @@ function foreignPollLockHolder(token, selfPid = process.pid) {
   const file = telegramPollLockPath(token);
   let pid;
   try {
-    const parsed = Number.parseInt(fs12.readFileSync(file, "utf8").trim(), 10);
+    const parsed = Number.parseInt(fs13.readFileSync(file, "utf8").trim(), 10);
     if (!Number.isFinite(parsed))
       return null;
     pid = parsed;
@@ -7287,9 +7368,9 @@ function notifyToggle(text) {
   return null;
 }
 function createTelegramBridge(opts) {
-  const { cfg, stateRoot, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
+  const { cfg, stateRoot: stateRoot2, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
   const lifecycle = opts.lifecycle;
-  const configRoot = opts.configRoot ?? path14.join(os6.homedir(), ".config", "squadrant");
+  const configRoot = opts.configRoot ?? path15.join(os7.homedir(), ".config", "squadrant");
   const pollMs = cfg.pollMs ?? 1e3;
   const schedule = opts.schedule ?? defaultSchedule2;
   const lockToken = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
@@ -7303,17 +7384,17 @@ function createTelegramBridge(opts) {
   let lastError = null;
   let lastErrorAt = null;
   function persistOffset(next) {
-    const s = loadState(stateRoot);
+    const s = loadState(stateRoot2);
     s.offset = next;
-    saveState(stateRoot, s);
+    saveState(stateRoot2, s);
   }
   async function sendToTopic(project, text) {
-    const { topicId } = await runTelegramLink({ project, cfg, client, stateRoot });
+    const { topicId } = await runTelegramLink({ project, cfg, client, stateRoot: stateRoot2 });
     await client.sendMessage(cfg.supergroupId, topicId, text);
   }
   async function deliverOutbound(project, ev2) {
     const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
-    const live = loadState(stateRoot).notify[project];
+    const live = loadState(stateRoot2).notify[project];
     const active = live ?? resolved.active;
     if (!active)
       return;
@@ -7333,7 +7414,7 @@ ${formatUsageLine(usage2)}`;
   }
   function resolveLiveNotify(project) {
     const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
-    const live = loadState(stateRoot).notify[project];
+    const live = loadState(stateRoot2).notify[project];
     return { ...resolved, active: live ?? resolved.active };
   }
   async function editMarkup(chatId, messageId, markup) {
@@ -7363,14 +7444,14 @@ ${formatUsageLine(usage2)}`;
       const chatId = cq.message.chat.id;
       const messageId = cq.message.message_id;
       if (action.t === "notify") {
-        const resolved = findProjectByThread(stateRoot, cq.message.message_thread_id ?? -1);
+        const resolved = findProjectByThread(stateRoot2, cq.message.message_thread_id ?? -1);
         if (!resolved) {
           await client.answerCallbackQuery(cq.id, "no project for this topic");
           return;
         }
         const project2 = resolved.project;
         if (action.dim === "active") {
-          setNotify(stateRoot, project2, action.val === "on");
+          setNotify(stateRoot2, project2, action.val === "on");
         } else if (action.dim === "cap") {
           saveProjectOverride(project2, { telegram: { notify: { cap: action.val === "on" } } }, configRoot);
         } else {
@@ -7402,10 +7483,10 @@ ${formatUsageLine(usage2)}`;
           await runCommand(["launch", project]);
         await client.answerCallbackQuery(cq.id, `launching ${project}`);
       } else if (act === "mu") {
-        setNotify(stateRoot, project, false);
+        setNotify(stateRoot2, project, false);
         await client.answerCallbackQuery(cq.id, `\u{1F515} muted ${project}`);
       } else {
-        setNotify(stateRoot, project, true);
+        setNotify(stateRoot2, project, true);
         await client.answerCallbackQuery(cq.id, `\u{1F514} unmuted ${project}`);
       }
     } catch (e) {
@@ -7430,14 +7511,14 @@ ${formatUsageLine(usage2)}`;
   }
   function currentEffort() {
     try {
-      return loadConfig(path14.join(configRoot, "config.json")).defaults.effort ?? "balance";
+      return loadConfig(path15.join(configRoot, "config.json")).defaults.effort ?? "balance";
     } catch {
       return "balance";
     }
   }
   function projectNames() {
     try {
-      return Object.keys(loadConfig(path14.join(configRoot, "config.json")).projects);
+      return Object.keys(loadConfig(path15.join(configRoot, "config.json")).projects);
     } catch {
       return [];
     }
@@ -7497,7 +7578,7 @@ ${formatUsageLine(usage2)}`;
     await runChannelCommand(text, fromId, void 0);
   }
   async function handleProjectTopic(text, threadId, fromId, messageId, media) {
-    const resolved = findProjectByThread(stateRoot, threadId);
+    const resolved = findProjectByThread(stateRoot2, threadId);
     if (!resolved) {
       log(`telegram inbound in unbound topic thread=${threadId} \u2014 no project linked, message dropped`);
       await reply(threadId, "\u26A0\uFE0F this topic isn't linked to a project \u2014 run: squadrant telegram link <project>");
@@ -7517,7 +7598,7 @@ ${formatUsageLine(usage2)}`;
         await reply(threadId, "\u26D4 not authorized");
         return;
       }
-      setNotify(stateRoot, resolved.project, toggle);
+      setNotify(stateRoot2, resolved.project, toggle);
       await reply(threadId, toggle ? `\u{1F514} ${resolved.project} notifications ON` : `\u{1F515} ${resolved.project} notifications OFF`);
       return;
     }
@@ -7555,7 +7636,7 @@ ${formatUsageLine(usage2)}`;
     if (messageId !== void 0) {
       void Promise.resolve(client.setMessageReaction?.(cfg.supergroupId, messageId, "\u{1F44D}")).catch((e) => log(`telegram stage-1 reaction failed project=${resolved.project}: ${e.message}`));
     }
-    setNotify(stateRoot, resolved.project, true);
+    setNotify(stateRoot2, resolved.project, true);
     if (ensureCaptainAlive && isControlEnabled(cfg) && isAuthorized(fromId, cfg)) {
       void ensureCaptainAlive(resolved.project).then((r) => {
         if (r === "timeout") {
@@ -7572,7 +7653,7 @@ ${formatUsageLine(usage2)}`;
     }
     const deliveryHeld = outcome?.status === "held";
     if (!handled) {
-      await appendCaptainMessage2({ stateRoot, project: resolved.project, text: formatInbound(text), source: "telegram" });
+      await appendCaptainMessage2({ stateRoot: stateRoot2, project: resolved.project, text: formatInbound(text), source: "telegram" });
       outcome = void 0;
     }
     const receipt = formatInboundReceipt(resolved.project, outcome);
@@ -7601,8 +7682,8 @@ ${formatUsageLine(usage2)}`;
       return;
     if (!cfg.chats.includes(m.chat.id))
       return;
-    if (m.from?.id !== void 0 && loadState(stateRoot).lastUserId !== m.from.id) {
-      setLastUserId(stateRoot, m.from.id);
+    if (m.from?.id !== void 0 && loadState(stateRoot2).lastUserId !== m.from.id) {
+      setLastUserId(stateRoot2, m.from.id);
     }
     const spawnProject = parseSpawnPrompt(m.reply_to_message?.text);
     if (spawnProject) {
@@ -7661,7 +7742,7 @@ ${formatUsageLine(usage2)}`;
       pollAbort = ac;
       let waitMs = pollMs;
       try {
-        const offset = loadState(stateRoot).offset;
+        const offset = loadState(stateRoot2).offset;
         const updates = await client.getUpdates(offset, LONG_POLL_SEC, ac.signal);
         conflictCount = 0;
         for (const u of updates) {
@@ -7709,7 +7790,7 @@ ${formatUsageLine(usage2)}`;
       const known = opts.registeredProjects?.();
       if (known !== void 0) {
         try {
-          const removed = pruneTopics(stateRoot, (p) => known.includes(p));
+          const removed = pruneTopics(stateRoot2, (p) => known.includes(p));
           if (removed.length > 0)
             log(`telegram registry pruned ${removed.length} stale topic link(s): ${removed.join(", ")}`);
         } catch (e) {
@@ -7779,9 +7860,9 @@ var init_bridge = __esm({
 
 // packages/core/dist/restart-daemon.js
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 function defaultIsRunning() {
-  return existsSync10(DAEMON_SOCK_PATH);
+  return existsSync11(DAEMON_SOCK_PATH);
 }
 function defaultRunKickstart() {
   const uid = process.getuid?.() ?? 0;
@@ -7815,7 +7896,7 @@ var init_restart_daemon = __esm({
 });
 
 // packages/core/dist/telegram/setup.js
-import fs13 from "fs";
+import fs14 from "fs";
 function resolveSetupGroup(existingSupergroupId, opts) {
   if (existingSupergroupId !== void 0 && !opts.redetect)
     return "reuse";
@@ -7847,8 +7928,8 @@ function resolveSetupToken(existingToken, opts) {
     return "prompt";
   return "try-reuse";
 }
-function resolveSetupUserId(flagUserId, detectedUserId, stateRoot) {
-  return flagUserId ?? detectedUserId ?? loadState(stateRoot).lastUserId;
+function resolveSetupUserId(flagUserId, detectedUserId, stateRoot2) {
+  return flagUserId ?? detectedUserId ?? loadState(stateRoot2).lastUserId;
 }
 async function runRegisterCommands(opts) {
   await opts.client.setMyCommands(BOT_COMMANDS);
@@ -7866,7 +7947,7 @@ function writeTelegramConfig(configPath, opts) {
   let config;
   let raw = null;
   try {
-    raw = fs13.readFileSync(configPath, "utf-8");
+    raw = fs14.readFileSync(configPath, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(`refusing to overwrite unreadable config at ${configPath}: ${String(err)}`);
@@ -8098,8 +8179,8 @@ var init_stream = __esm({
 // packages/core/dist/router/shim.js
 import { createServer as createServer3 } from "http";
 import { Readable } from "stream";
-function joinUrl(base, path43) {
-  return base.replace(/\/+$/, "") + path43;
+function joinUrl(base, path44) {
+  return base.replace(/\/+$/, "") + path44;
 }
 async function readBody(req) {
   const chunks = [];
@@ -8275,8 +8356,8 @@ function createRouterShim(opts) {
     writeJson(res, 200, { input_tokens: Math.max(1, Math.ceil(text.length / 4)) });
   }
   function handler(req, res) {
-    const path43 = pathnameOf(req.url);
-    if (req.method === "POST" && path43 === "/v1/messages") {
+    const path44 = pathnameOf(req.url);
+    if (req.method === "POST" && path44 === "/v1/messages") {
       void handleMessages(req, res).catch((err) => {
         log(`router internal error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
@@ -8288,18 +8369,18 @@ function createRouterShim(opts) {
       });
       return;
     }
-    if (req.method === "POST" && path43 === "/v1/messages/count_tokens") {
+    if (req.method === "POST" && path44 === "/v1/messages/count_tokens") {
       void handleCountTokens(req, res).catch(() => {
         if (!res.headersSent)
           writeJson(res, 502, anthropicError(502, "api_error", "router internal error").body);
       });
       return;
     }
-    if (req.method === "GET" && path43 === "/v1/models") {
+    if (req.method === "GET" && path44 === "/v1/models") {
       writeJson(res, 200, modelsList([...advertisedModels]));
       return;
     }
-    if (req.method === "GET" && path43 === "/healthz") {
+    if (req.method === "GET" && path44 === "/healthz") {
       writeJson(res, 200, { ready: server?.listening === true, upstreamReachable, lastError });
       return;
     }
@@ -8311,7 +8392,7 @@ function createRouterShim(opts) {
         return;
       if (starting)
         return starting;
-      starting = new Promise((resolve4, reject) => {
+      starting = new Promise((resolve5, reject) => {
         const s = createServer3(handler);
         const onStartupError = (err) => {
           s.off("error", onStartupError);
@@ -8327,7 +8408,7 @@ function createRouterShim(opts) {
           server = s;
           const addr = s.address();
           boundPort = typeof addr === "object" && addr ? addr.port : 0;
-          resolve4();
+          resolve5();
         });
       });
       try {
@@ -8347,7 +8428,7 @@ function createRouterShim(opts) {
       server = void 0;
       boundPort = 0;
       s.closeAllConnections?.();
-      await new Promise((resolve4) => s.close(() => resolve4()));
+      await new Promise((resolve5) => s.close(() => resolve5()));
     },
     url() {
       return `http://${opts.host ?? "127.0.0.1"}:${boundPort}`;
@@ -8541,7 +8622,6 @@ var init_captain_router = __esm({
 // packages/core/dist/group-dispatch.js
 import { randomUUID as randomUUID4 } from "crypto";
 import { createConnection as createConnection2 } from "net";
-import { join as join16 } from "path";
 function resolveCurrentProject(config) {
   const cwd = process.cwd();
   for (const [name, proj] of Object.entries(config.projects)) {
@@ -8552,8 +8632,8 @@ function resolveCurrentProject(config) {
   return null;
 }
 async function probeCaptainChannel(project, opts = {}) {
-  const stateRoot = opts.stateRoot ?? join16(CONFIG_DIR, "state");
-  const addr = readCaptainAddress(stateRoot, project);
+  const stateRoot2 = opts.stateRoot ?? stateRoot();
+  const addr = readCaptainAddress(stateRoot2, project);
   if (!addr)
     return false;
   if (addr.agent === "opencode") {
@@ -8568,11 +8648,11 @@ async function probeCaptainChannel(project, opts = {}) {
   }
 }
 async function httpReachable(port, fetchImpl, timeoutMs) {
-  for (const path43 of ["/session", "/api/session"]) {
+  for (const path44 of ["/session", "/api/session"]) {
     const ac = new AbortController();
     const t = setTimeout(() => ac.abort(), timeoutMs);
     try {
-      const res = await fetchImpl(`http://127.0.0.1:${port}${path43}`, { signal: ac.signal });
+      const res = await fetchImpl(`http://127.0.0.1:${port}${path44}`, { signal: ac.signal });
       if (res.ok)
         return true;
     } catch {
@@ -8583,7 +8663,7 @@ async function httpReachable(port, fetchImpl, timeoutMs) {
   return false;
 }
 function socketAccepts(socketPath, timeoutMs = 2e3) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     const sock = createConnection2(socketPath);
     const done = (v2) => {
@@ -8591,7 +8671,7 @@ function socketAccepts(socketPath, timeoutMs = 2e3) {
         return;
       settled = true;
       sock.destroy();
-      resolve4(v2);
+      resolve5(v2);
     };
     sock.setTimeout(timeoutMs, () => done(false));
     sock.once("connect", () => done(true));
@@ -8751,6 +8831,7 @@ async function launchOneWorkspace(opts) {
   if (!forceFresh) {
     const auto = shouldStartFresh(opts.workspaceName, opts.role, {
       sessionsPath: opts.sessionsPath,
+      legacySessionsPath: opts.legacySessionsPath,
       templatesDir: opts.templatesDir
     });
     if (auto.fresh && opts.keepOverride && auto.reason !== "first launch") {
@@ -8764,6 +8845,7 @@ async function launchOneWorkspace(opts) {
   const agentCmd = opts.role === "captain" ? `SQUADRANT_ROLE=captain ${builtCmd}` : builtCmd;
   recordSession(opts.workspaceName, opts.role, {
     sessionsPath: opts.sessionsPath,
+    legacySessionsPath: opts.legacySessionsPath,
     templatesDir: opts.templatesDir
   });
   await bootWorkspace({
@@ -8790,7 +8872,7 @@ var init_launch_workspace = __esm({
 });
 
 // packages/core/dist/side-session.js
-import fs14 from "fs";
+import fs15 from "fs";
 function sideTitleFor(project, name) {
   return `\u{1F5D2} ${project}:${name}`;
 }
@@ -8812,7 +8894,7 @@ function sideNextAutoName(existingTitles, project) {
     i++;
   return `side-${i}`;
 }
-function buildSideFirstTurn(topic, project, role, spokeVault, scratchWorktree) {
+function buildSideFirstTurn(topic, project, role, workspace, scratchWorktree) {
   const lines = [
     topic,
     "",
@@ -8820,7 +8902,7 @@ function buildSideFirstTurn(topic, project, role, spokeVault, scratchWorktree) {
     "Side-session context (for handoff use):",
     `Project: ${project}`,
     `Role: ${role}`,
-    `Spoke vault: ${spokeVault}`
+    `Workspace: ${workspace}`
   ];
   if (scratchWorktree) {
     lines.push(`Scratch worktree: ${scratchWorktree}`);
@@ -8862,7 +8944,7 @@ async function runSideSpawn(input, config, deps) {
   const pane = await runtime.newPane({ workspaceId: captain.id, direction, title });
   await runtime.sendToPane(pane, `cd ${shellQuote(spawnCwd)} && ${SIDE_SESSION_ENV}=1 ${agentCmd}`);
   const preLaunchScreen = await runtime.readPaneScreen(pane) ?? "";
-  const firstTurn = buildSideFirstTurn(input.topic, input.project, input.role, proj.spokeVault ?? "", input.role === "debug" ? spawnCwd : void 0);
+  const firstTurn = buildSideFirstTurn(input.topic, input.project, input.role, workspacePath(input.project), input.role === "debug" ? spawnCwd : void 0);
   await deps.sendFirstTurn(pane, spillOversizedFirstTurn(firstTurn, `side-${input.project}-${name}`), preLaunchScreen);
   return { ...pane, title };
 }
@@ -8897,7 +8979,7 @@ async function runSideClose(runtime, workspaceId, project, name, projPath, workt
   }
   if (projPath) {
     const wtPath = worktreePath(projPath, worktreeDir, project, name);
-    if (fs14.existsSync(wtPath)) {
+    if (fs15.existsSync(wtPath)) {
       try {
         removeWorktree(projPath, wtPath);
       } catch (e) {
@@ -9411,15 +9493,15 @@ var init_peer_first_turn = __esm({
 });
 
 // packages/core/dist/knowledge/paths.js
-import path15 from "path";
+import path16 from "path";
 function kbDir(cfg, kb) {
   return kbPath(cfg, kb);
 }
 function kbRulesDir(cfg, kb) {
-  return path15.join(kbDir(cfg, kb), "shared", "rules");
+  return path16.join(kbDir(cfg, kb), "shared", "rules");
 }
 function legacyKbDir(hubVault, kb) {
-  return path15.join(hubVault, "knowledge", kb);
+  return path16.join(hubVault, "knowledge", kb);
 }
 var PROPOSED_DIR;
 var init_paths = __esm({
@@ -9431,28 +9513,28 @@ var init_paths = __esm({
 
 // packages/core/dist/knowledge/ingest.js
 import crypto3 from "crypto";
-import fs15 from "fs";
-import os7 from "os";
-import path16 from "path";
+import fs16 from "fs";
+import os8 from "os";
+import path17 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 function refFor(kbRoot, file) {
-  const rel = path16.relative(kbRoot, file);
-  if (rel && !rel.startsWith("..") && !path16.isAbsolute(rel))
-    return rel.split(path16.sep).join("/");
-  const home = os7.homedir();
-  return file.startsWith(home + path16.sep) ? `~/${path16.relative(home, file).split(path16.sep).join("/")}` : file;
+  const rel = path17.relative(kbRoot, file);
+  if (rel && !rel.startsWith("..") && !path17.isAbsolute(rel))
+    return rel.split(path17.sep).join("/");
+  const home = os8.homedir();
+  return file.startsWith(home + path17.sep) ? `~/${path17.relative(home, file).split(path17.sep).join("/")}` : file;
 }
 function readState2(kbRoot, ref) {
   try {
-    return JSON.parse(fs15.readFileSync(stampFile(kbRoot, ref), "utf8"));
+    return JSON.parse(fs16.readFileSync(stampFile(kbRoot, ref), "utf8"));
   } catch {
     return null;
   }
 }
 function writeState(kbRoot, st) {
-  fs15.mkdirSync(path16.join(kbRoot, CONVERTED_DIR), { recursive: true });
-  fs15.writeFileSync(stampFile(kbRoot, st.ref), JSON.stringify(st) + "\n");
+  fs16.mkdirSync(path17.join(kbRoot, CONVERTED_DIR), { recursive: true });
+  fs16.writeFileSync(stampFile(kbRoot, st.ref), JSON.stringify(st) + "\n");
 }
 function globToRegExp(glob) {
   let re = "";
@@ -9472,12 +9554,12 @@ function globToRegExp(glob) {
   return new RegExp(`^${re}$`);
 }
 function walkFiles(dir, out = []) {
-  if (!fs15.existsSync(dir))
+  if (!fs16.existsSync(dir))
     return out;
-  for (const ent of fs15.readdirSync(dir, { withFileTypes: true })) {
+  for (const ent of fs16.readdirSync(dir, { withFileTypes: true })) {
     if (ent.name === ".git" || ent.name === CONVERTED_DIR || ent.name === "node_modules")
       continue;
-    const full = path16.join(dir, ent.name);
+    const full = path17.join(dir, ent.name);
     if (ent.isDirectory())
       walkFiles(full, out);
     else if (ent.isFile())
@@ -9486,27 +9568,27 @@ function walkFiles(dir, out = []) {
   return out;
 }
 function expandSource(kbRoot, entry) {
-  const abs = path16.resolve(kbRoot, expandHome(entry.path));
+  const abs = path17.resolve(kbRoot, expandHome(entry.path));
   if (!/[*?]/.test(entry.path))
-    return fs15.existsSync(abs) && fs15.statSync(abs).isFile() ? [abs] : [];
+    return fs16.existsSync(abs) && fs16.statSync(abs).isFile() ? [abs] : [];
   const base = abs.split(/[*?]/)[0];
-  const root = base.endsWith(path16.sep) ? base : path16.dirname(base);
-  const re = globToRegExp(abs.split(path16.sep).join("/"));
-  return walkFiles(root).filter((f) => re.test(f.split(path16.sep).join("/"))).sort();
+  const root = base.endsWith(path17.sep) ? base : path17.dirname(base);
+  const re = globToRegExp(abs.split(path17.sep).join("/"));
+  return walkFiles(root).filter((f) => re.test(f.split(path17.sep).join("/"))).sort();
 }
 function refCandidates(kbRoot, sources, ref) {
-  const asIs = path16.resolve(kbRoot, expandHome(ref));
-  if (path16.isAbsolute(expandHome(ref)))
+  const asIs = path17.resolve(kbRoot, expandHome(ref));
+  if (path17.isAbsolute(expandHome(ref)))
     return [asIs];
   const bases = /* @__PURE__ */ new Set([kbRoot]);
   for (const s of sources) {
-    let d = path16.resolve(kbRoot, expandHome(s.path.split(/[*?[{]/)[0]));
-    for (let i = 0; i < 6 && d !== path16.dirname(d); i++) {
-      d = path16.dirname(d);
+    let d = path17.resolve(kbRoot, expandHome(s.path.split(/[*?[{]/)[0]));
+    for (let i = 0; i < 6 && d !== path17.dirname(d); i++) {
+      d = path17.dirname(d);
       bases.add(d);
     }
   }
-  return [.../* @__PURE__ */ new Set([asIs, ...[...bases].map((b) => path16.join(b, ref))])];
+  return [.../* @__PURE__ */ new Set([asIs, ...[...bases].map((b) => path17.join(b, ref))])];
 }
 function refPath(kbRoot, sources, ref) {
   const cands = refCandidates(kbRoot, sources, ref);
@@ -9525,7 +9607,7 @@ function refCanon(kbRoot, sources) {
 }
 function detectChange(kbRoot, file) {
   const ref = refFor(kbRoot, file);
-  const st = fs15.statSync(file);
+  const st = fs16.statSync(file);
   const prior = readState2(kbRoot, ref);
   if (prior && prior.size === st.size && prior.mtimeMs === st.mtimeMs) {
     return { ref, changed: false, stamp: { sha: prior.sha, size: st.size, mtimeMs: st.mtimeMs }, prior };
@@ -9582,13 +9664,13 @@ async function planIngest(kbRoot, opts) {
       let text;
       const conv = convertedFile(kbRoot, ref);
       try {
-        if (!changed && fs15.existsSync(conv))
-          text = fs15.readFileSync(conv, "utf8");
+        if (!changed && fs16.existsSync(conv))
+          text = fs16.readFileSync(conv, "utf8");
         else {
-          text = PASS_THROUGH.has(path16.extname(file).toLowerCase()) ? fs15.readFileSync(file, "utf8") : await converter(file);
+          text = PASS_THROUGH.has(path17.extname(file).toLowerCase()) ? fs16.readFileSync(file, "utf8") : await converter(file);
           if (!opts.dryRun) {
-            fs15.mkdirSync(path16.dirname(conv), { recursive: true });
-            fs15.writeFileSync(conv, text);
+            fs16.mkdirSync(path17.dirname(conv), { recursive: true });
+            fs16.writeFileSync(conv, text);
           }
         }
       } catch (e) {
@@ -9632,19 +9714,19 @@ var init_ingest = __esm({
       const { stdout } = await execFileAsync("markitdown", [file], { maxBuffer: 64 * 1024 * 1024 });
       return stdout;
     };
-    expandHome = (p) => p === "~" || p.startsWith("~/") ? path16.join(os7.homedir(), p.slice(1)) : p;
+    expandHome = (p) => p === "~" || p.startsWith("~/") ? path17.join(os8.homedir(), p.slice(1)) : p;
     cacheKey = (ref) => `${ref.replace(/[^A-Za-z0-9._-]+/g, "_")}.${crypto3.createHash("sha1").update(ref).digest("hex").slice(0, 6)}`;
-    convertedFile = (kbRoot, ref) => path16.join(kbRoot, CONVERTED_DIR, `${cacheKey(ref)}.md`);
-    stampFile = (kbRoot, ref) => path16.join(kbRoot, CONVERTED_DIR, `${cacheKey(ref)}.sha`);
-    isFile = (f) => fs15.existsSync(f) && fs15.statSync(f).isFile();
+    convertedFile = (kbRoot, ref) => path17.join(kbRoot, CONVERTED_DIR, `${cacheKey(ref)}.md`);
+    stampFile = (kbRoot, ref) => path17.join(kbRoot, CONVERTED_DIR, `${cacheKey(ref)}.sha`);
+    isFile = (f) => fs16.existsSync(f) && fs16.statSync(f).isFile();
     resolveSourceRef = (kbRoot, sources, ref) => refCandidates(kbRoot, sources, ref).find(isFile);
     entryCovers = (kbRoot, entry, file) => {
-      const abs = path16.resolve(kbRoot, expandHome(entry.path));
-      return /[*?]/.test(entry.path) ? globToRegExp(abs.split(path16.sep).join("/")).test(file.split(path16.sep).join("/")) : abs === file;
+      const abs = path17.resolve(kbRoot, expandHome(entry.path));
+      return /[*?]/.test(entry.path) ? globToRegExp(abs.split(path17.sep).join("/")).test(file.split(path17.sep).join("/")) : abs === file;
     };
     sourceCovers = (kbRoot, sources, entry, ref) => entryCovers(kbRoot, entry, refPath(kbRoot, sources, ref));
     isGatedRef = (kbRoot, sources, ref) => sources.some((e) => e.review === "required" && sourceCovers(kbRoot, sources, e, ref));
-    sha256 = (file) => crypto3.createHash("sha256").update(fs15.readFileSync(file)).digest("hex");
+    sha256 = (file) => crypto3.createHash("sha256").update(fs16.readFileSync(file)).digest("hex");
   }
 });
 
@@ -9725,14 +9807,14 @@ var init_verify = __esm({
 });
 
 // packages/core/dist/knowledge/store.js
-import fs16 from "fs";
-import path17 from "path";
+import fs17 from "fs";
+import path18 from "path";
 import matter2 from "gray-matter";
 function duplicateIdProblem(id, ignored, used) {
   return `duplicate id ${id}: ${ignored} is ignored, ${used} is used (live files win over _proposed, then path order). Fix: rename the id in one file, or delete or move one of them.`;
 }
 function isPendingProposalDup(e, rulesDir) {
-  return e.problems.every((p) => p.startsWith("duplicate id")) && path17.relative(rulesDir, e.file).split(path17.sep).includes(PROPOSED_DIR);
+  return e.problems.every((p) => p.startsWith("duplicate id")) && path18.relative(rulesDir, e.file).split(path18.sep).includes(PROPOSED_DIR);
 }
 function splitStatement(body) {
   const first = body.trim().split(/\n\s*\n/)[0] ?? "";
@@ -9741,8 +9823,8 @@ function splitStatement(body) {
 function listMarkdown(dir, includeProposed) {
   const out = [];
   const walk = (d) => {
-    for (const ent of fs16.readdirSync(d, { withFileTypes: true })) {
-      const full = path17.join(d, ent.name);
+    for (const ent of fs17.readdirSync(d, { withFileTypes: true })) {
+      const full = path18.join(d, ent.name);
       if (ent.isDirectory()) {
         if (ent.name === PROPOSED_DIR && !includeProposed)
           continue;
@@ -9753,11 +9835,11 @@ function listMarkdown(dir, includeProposed) {
     }
   };
   walk(dir);
-  const isProposed = (f) => path17.relative(dir, f).split(path17.sep).includes(PROPOSED_DIR);
+  const isProposed = (f) => path18.relative(dir, f).split(path18.sep).includes(PROPOSED_DIR);
   return out.sort((a, b) => Number(isProposed(a)) - Number(isProposed(b)) || (a < b ? -1 : a > b ? 1 : 0));
 }
 function loadRulesDir(dir, layer, opts = {}) {
-  if (!fs16.existsSync(dir))
+  if (!fs17.existsSync(dir))
     return { rules: [], errors: [] };
   const rules = [];
   const errors = [];
@@ -9765,7 +9847,7 @@ function loadRulesDir(dir, layer, opts = {}) {
   for (const file of listMarkdown(dir, opts.includeProposed ?? false)) {
     let parsed;
     try {
-      parsed = matter2(fs16.readFileSync(file, "utf8"), NO_JS_FRONTMATTER);
+      parsed = matter2(fs17.readFileSync(file, "utf8"), NO_JS_FRONTMATTER);
     } catch (e) {
       errors.push({ file, problems: [`frontmatter parse error: ${e.message}`] });
       continue;
@@ -9792,7 +9874,7 @@ function validateKb(opts) {
   const dups = errors.filter((e) => e.problems.some((p) => p.startsWith("duplicate id")) && !isPendingProposalDup(e, opts.rulesDir));
   const pendingDups = errors.filter((e) => isPendingProposalDup(e, opts.rulesDir)).length;
   const invalid = errors.filter((e) => !dups.includes(e) && !isPendingProposalDup(e, opts.rulesDir));
-  const proposed = rules.filter((r) => path17.relative(opts.rulesDir, r.file).split(path17.sep).includes(PROPOSED_DIR)).length;
+  const proposed = rules.filter((r) => path18.relative(opts.rulesDir, r.file).split(path18.sep).includes(PROPOSED_DIR)).length;
   checks.push({ level: "ok", message: `${rules.length + errors.length} rule files read (${rules.length - proposed} live, ${proposed + pendingDups} proposed parsed OK)` });
   if (invalid.length)
     for (const e of invalid)
@@ -9817,17 +9899,17 @@ function validateKb(opts) {
       const key = `${src.ref}\0${file}`;
       if (!cache.has(key)) {
         const conv = readState2(opts.kbRoot, canon(src.ref)) ? convertedFile(opts.kbRoot, canon(src.ref)) : null;
-        const cached = !!conv && fs16.existsSync(conv);
+        const cached = !!conv && fs17.existsSync(conv);
         cache.set(key, {
-          hay: normalizedViews(fs16.readFileSync(cached ? conv : file, "utf8")),
-          convertible: !cached && !PASS_THROUGH.has(path17.extname(file).toLowerCase())
+          hay: normalizedViews(fs17.readFileSync(cached ? conv : file, "utf8")),
+          convertible: !cached && !PASS_THROUGH.has(path18.extname(file).toLowerCase())
         });
       }
       const { hay, convertible } = cache.get(key);
       const span = findQuote(hay, src.quote);
       if (span) {
         verified++;
-        const active = r.status === "active" && !path17.relative(opts.rulesDir, r.file).split(path17.sep).includes(PROPOSED_DIR);
+        const active = r.status === "active" && !path18.relative(opts.rulesDir, r.file).split(path18.sep).includes(PROPOSED_DIR);
         const err = active ? (opts.errata ?? []).find((e) => canon(e.ref) === canon(src.ref) && ((o) => !!o && spansOverlap(o, span))(findQuote(hay, e.quote))) : void 0;
         if (err)
           checks.push({ level: "warn", message: `${r.id}: grounded in erratum ${err.id} (${err.reason}); re-check or retire it (${r.file})` });
@@ -9867,7 +9949,7 @@ var init_store2 = __esm({
 });
 
 // packages/core/dist/knowledge/layers.js
-import fs17 from "fs";
+import fs18 from "fs";
 function loadKbRules(cfg, kb, opts = {}) {
   return loadRulesDir(kbRulesDir(cfg, kb), `kb:${kb}`, opts);
 }
@@ -9879,7 +9961,7 @@ function resolveProjectRules(cfg, project, opts = {}) {
   const errors = [];
   const warnings = [];
   for (const kb of subscribedKbs(cfg, project)) {
-    if (!fs17.existsSync(kbDir(cfg, kb))) {
+    if (!fs18.existsSync(kbDir(cfg, kb))) {
       warnings.push(`knowledge base '${kb}' not found (run: squadrant knowledge init ${kb})`);
       continue;
     }
@@ -9917,8 +9999,8 @@ var init_layers = __esm({
 });
 
 // packages/core/dist/knowledge/index-file.js
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 function compileIndex(kb, rules, now = /* @__PURE__ */ new Date()) {
   return {
     kb,
@@ -9927,18 +10009,18 @@ function compileIndex(kb, rules, now = /* @__PURE__ */ new Date()) {
   };
 }
 function writeIndex(kbRoot, index) {
-  const file = path18.join(kbRoot, "index.json");
+  const file = path19.join(kbRoot, "index.json");
   const tmp = `${file}.tmp-${process.pid}`;
-  fs18.writeFileSync(tmp, JSON.stringify(index, null, 2) + "\n");
-  fs18.renameSync(tmp, file);
+  fs19.writeFileSync(tmp, JSON.stringify(index, null, 2) + "\n");
+  fs19.renameSync(tmp, file);
   return file;
 }
 function readIndex(kbRoot, kb) {
-  const file = path18.join(kbRoot, "index.json");
-  if (!fs18.existsSync(file))
+  const file = path19.join(kbRoot, "index.json");
+  if (!fs19.existsSync(file))
     return { index: null, problem: `index.json missing for kb '${kb}'` };
   try {
-    const index = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const index = JSON.parse(fs19.readFileSync(file, "utf8"));
     if (!Array.isArray(index.rules))
       return { index: null, problem: `index.json corrupt for kb '${kb}' (no rules array)` };
     return { index };
@@ -13033,16 +13115,16 @@ var init_js_yaml = __esm({
 });
 
 // packages/core/dist/knowledge/sources.js
-import fs19 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path20 from "path";
 import matter3 from "gray-matter";
 function loadSources(kbRoot) {
-  const file = path19.join(kbRoot, "sources.yaml");
-  if (!fs19.existsSync(file))
+  const file = path20.join(kbRoot, "sources.yaml");
+  if (!fs20.existsSync(file))
     return { sources: [], errors: [] };
   let data;
   try {
-    data = yaml.load(fs19.readFileSync(file, "utf8"));
+    data = yaml.load(fs20.readFileSync(file, "utf8"));
   } catch (e) {
     return { sources: [], errors: [`YAML parse error: ${e.message.split("\n")[0]}`] };
   }
@@ -13074,12 +13156,12 @@ function dropEntryBlock(text, entryPath) {
   return [...lines.slice(0, i), ...lines.slice(j)].join("\n");
 }
 function removeSource(kbRoot, rulesDir, entryPath, opts = {}) {
-  const file = path19.join(kbRoot, "sources.yaml");
+  const file = path20.join(kbRoot, "sources.yaml");
   const { sources } = loadSources(kbRoot);
   const entry = sources.find((s) => s.path === entryPath);
   if (!entry)
     throw new Error(`no sources.yaml entry with path '${entryPath}' (give it exactly as listed by \`knowledge sources\`)`);
-  const edited = dropEntryBlock(fs19.readFileSync(file, "utf8"), entryPath);
+  const edited = dropEntryBlock(fs20.readFileSync(file, "utf8"), entryPath);
   if (edited === null)
     throw new Error(`could not edit sources.yaml for '${entryPath}' (not a plain block entry); remove it by hand, then rerun to strip the refs`);
   const res = { dryRun: !!opts.dryRun, entryRemoved: true, stripped: [], stale: [] };
@@ -13089,7 +13171,7 @@ function removeSource(kbRoot, rulesDir, entryPath, opts = {}) {
     if (kept.length === rule.sources.length)
       continue;
     res.stripped.push(rule.id);
-    const parsed = matter3(fs19.readFileSync(rule.file, "utf8"), { engines: { javascript: () => {
+    const parsed = matter3(fs20.readFileSync(rule.file, "utf8"), { engines: { javascript: () => {
       throw new Error("only YAML front matter is allowed");
     } } });
     const fm = { ...parsed.data, sources: kept };
@@ -13105,9 +13187,9 @@ function removeSource(kbRoot, rulesDir, entryPath, opts = {}) {
   if (opts.dryRun)
     return res;
   for (const w of writes)
-    fs19.writeFileSync(w.file, w.text);
-  fs19.writeFileSync(file, edited);
-  const name = opts.kbName ?? path19.basename(kbRoot);
+    fs20.writeFileSync(w.file, w.text);
+  fs20.writeFileSync(file, edited);
+  const name = opts.kbName ?? path20.basename(kbRoot);
   writeIndex(kbRoot, compileIndex(name, loadRulesDir(rulesDir, `kb:${name}`).rules));
   return res;
 }
@@ -13138,25 +13220,25 @@ var init_sources = __esm({
 });
 
 // packages/core/dist/knowledge/match.js
-import path20 from "path";
+import path21 from "path";
 function globMatches(glob, relPath) {
   const g = glob.replace(/^\.\//, "");
   if (globToRegExp(g).test(relPath))
     return true;
-  return !g.includes("/") && globToRegExp(g).test(path20.posix.basename(relPath));
+  return !g.includes("/") && globToRegExp(g).test(path21.posix.basename(relPath));
 }
 function repoRelativePaths(file, cwd, projectRoot) {
   const out = /* @__PURE__ */ new Set();
   const add = (base) => {
-    const rel = path20.relative(base, file).split(path20.sep).join("/");
-    if (!rel || rel.startsWith("..") || path20.isAbsolute(rel))
+    const rel = path21.relative(base, file).split(path21.sep).join("/");
+    if (!rel || rel.startsWith("..") || path21.isAbsolute(rel))
       return;
     out.add(rel);
     const wt = /^\.worktrees\/[^/]+\/(.+)$/.exec(rel);
     if (wt)
       out.add(wt[1]);
   };
-  if (path20.isAbsolute(file)) {
+  if (path21.isAbsolute(file)) {
     add(cwd);
     add(projectRoot);
   } else
@@ -13205,25 +13287,27 @@ var init_match = __esm({
 });
 
 // packages/core/dist/knowledge/audit.js
-import fs20 from "fs";
-import os8 from "os";
-import path21 from "path";
+import fs21 from "fs";
+import os9 from "os";
+import path22 from "path";
 function appendAudit(events, sink = {}) {
   if (!events.length)
     return;
   try {
     const ts = (sink.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+    const task = (sink.env ?? process.env).SQUADRANT_CREW_TASK_ID;
     const dir = sink.dir ?? defaultAuditDir();
-    const file = path21.join(dir, `${ts.slice(0, 7)}.${sink.machineId ?? auditMachineId()}.jsonl`);
-    fs20.mkdirSync(dir, { recursive: true });
-    const fd = fs20.openSync(file, "a");
+    const file = path22.join(dir, `${ts.slice(0, 7)}.${sink.machineId ?? auditMachineId()}.jsonl`);
+    fs21.mkdirSync(dir, { recursive: true });
+    const fd = fs21.openSync(file, "a");
     try {
       for (const e of events) {
         const q = e.query === void 0 ? {} : { query: e.query.slice(0, AUDIT_QUERY_CHARS) };
-        fs20.writeSync(fd, JSON.stringify({ ts, ...e, ...q }) + "\n");
+        const t = task && e.task === void 0 && DELIVERY_EVENTS.has(e.event) ? { task } : {};
+        fs21.writeSync(fd, JSON.stringify({ ts, ...e, ...q, ...t }) + "\n");
       }
     } finally {
-      fs20.closeSync(fd);
+      fs21.closeSync(fd);
     }
   } catch (err) {
     console.error(`squadrant audit: log write failed: ${err.message}`);
@@ -13232,18 +13316,22 @@ function appendAudit(events, sink = {}) {
 function ruleAuditScope(rule) {
   return rule.layer.startsWith("kb:") ? { kb: rule.layer.slice(3), level: "group" } : { kb: "", level: "project" };
 }
-var AUDIT_QUERY_CHARS, defaultAuditDir, auditMachineId;
+var OUTCOME_SOURCES, outcomeSource, RATED_SOURCES, DELIVERY_EVENTS, AUDIT_QUERY_CHARS, defaultAuditDir, auditMachineId;
 var init_audit = __esm({
   "packages/core/dist/knowledge/audit.js"() {
+    OUTCOME_SOURCES = ["operator", "review", "crew", "reconcile", "judge", "check"];
+    outcomeSource = (e) => typeof e.source === "string" && e.source ? e.source : "operator";
+    RATED_SOURCES = /* @__PURE__ */ new Set(["operator", "review", "judge", "check"]);
+    DELIVERY_EVENTS = /* @__PURE__ */ new Set(["item.surfaced", "item.shown", "item.searched"]);
     AUDIT_QUERY_CHARS = 200;
-    defaultAuditDir = () => process.env.SQUADRANT_AUDIT_DIR || path21.join(os8.homedir(), ".local", "state", "squadrant", "audit");
-    auditMachineId = () => os8.hostname().replace(/[^A-Za-z0-9_-]/g, "_") || "host";
+    defaultAuditDir = () => process.env.SQUADRANT_AUDIT_DIR || path22.join(os9.homedir(), ".local", "state", "squadrant", "audit");
+    auditMachineId = () => os9.hostname().replace(/[^A-Za-z0-9_-]/g, "_") || "host";
   }
 });
 
 // packages/core/dist/knowledge/inject.js
-import fs21 from "fs";
-import path22 from "path";
+import fs22 from "fs";
+import path23 from "path";
 function sessionOrder(a, b) {
   const proj = (r) => r.layer.startsWith("project:") ? 0 : 1;
   const mod = (r) => r.modality === "must-not" ? 0 : 1;
@@ -13317,7 +13405,7 @@ function promptText(prompt) {
   if (!m)
     return prompt;
   try {
-    return fs21.readFileSync(m[1], "utf8").slice(0, MAX_PROMPT_CHARS * 2);
+    return fs22.readFileSync(m[1], "utf8").slice(0, MAX_PROMPT_CHARS * 2);
   } catch {
     return prompt;
   }
@@ -13361,39 +13449,39 @@ function rulesFallbackPointer(kbs) {
     "Before changing code, look up the rules that apply with `squadrant rules search <terms>`, then `squadrant rules show <id>`."
   ].join("\n");
 }
-function injectStateDir(stateRoot) {
-  return path22.join(stateRoot, "rules-inject");
+function injectStateDir(stateRoot2) {
+  return path23.join(stateRoot2, "rules-inject");
 }
-function readSeenRules(stateRoot, sessionId) {
+function readSeenRules(stateRoot2, sessionId) {
   try {
-    const ids = JSON.parse(fs21.readFileSync(sessionFile(stateRoot, sessionId), "utf8"));
+    const ids = JSON.parse(fs22.readFileSync(sessionFile(stateRoot2, sessionId), "utf8"));
     return new Set(Array.isArray(ids) ? ids.filter((x) => typeof x === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
-function recordSeenRules(stateRoot, sessionId, ids) {
+function recordSeenRules(stateRoot2, sessionId, ids) {
   if (!ids.length)
     return;
-  const seen = readSeenRules(stateRoot, sessionId);
+  const seen = readSeenRules(stateRoot2, sessionId);
   for (const id of ids)
     seen.add(id);
-  fs21.mkdirSync(injectStateDir(stateRoot), { recursive: true });
-  fs21.writeFileSync(sessionFile(stateRoot, sessionId), JSON.stringify([...seen]));
+  fs22.mkdirSync(injectStateDir(stateRoot2), { recursive: true });
+  fs22.writeFileSync(sessionFile(stateRoot2, sessionId), JSON.stringify([...seen]));
 }
-function pruneSeenRules(stateRoot, now = Date.now()) {
-  const dir = injectStateDir(stateRoot);
+function pruneSeenRules(stateRoot2, now = Date.now()) {
+  const dir = injectStateDir(stateRoot2);
   let names;
   try {
-    names = fs21.readdirSync(dir);
+    names = fs22.readdirSync(dir);
   } catch {
     return;
   }
   for (const n of names) {
-    const f = path22.join(dir, n);
+    const f = path23.join(dir, n);
     try {
-      if (now - fs21.statSync(f).mtimeMs > SEEN_TTL_MS)
-        fs21.unlinkSync(f);
+      if (now - fs22.statSync(f).mtimeMs > SEEN_TTL_MS)
+        fs22.unlinkSync(f);
     } catch {
     }
   }
@@ -13402,8 +13490,8 @@ async function withBudget(fn, budgetMs = INJECT_BUDGET_MS) {
   const start = Date.now();
   let timer;
   try {
-    const timeout = new Promise((resolve4) => {
-      timer = setTimeout(() => resolve4(null), budgetMs);
+    const timeout = new Promise((resolve5) => {
+      timer = setTimeout(() => resolve5(null), budgetMs);
     });
     const out = await Promise.race([Promise.resolve().then(fn), timeout]);
     return Date.now() - start > budgetMs ? null : out;
@@ -13421,7 +13509,7 @@ function resolveInjectProject(cfg, cwd, env, project) {
   let bestLen = -1;
   for (const [name, pc] of Object.entries(cfg.projects)) {
     const root = resolveHome(pc.path);
-    if ((cwd === root || cwd.startsWith(root + path22.sep)) && root.length > bestLen) {
+    if ((cwd === root || cwd.startsWith(root + path23.sep)) && root.length > bestLen) {
       best = name;
       bestLen = root.length;
     }
@@ -13440,7 +13528,7 @@ function audit(i, project, session, trigger, items) {
     chars: line(rule).length,
     agent: i.agent ?? "claude",
     ...session ? { session } : {}
-  })), i.audit);
+  })), { env: i.env, ...i.audit });
 }
 function computeRulesInjection(i) {
   if (i.env.SQUADRANT_RULES_INJECT === "0")
@@ -13529,23 +13617,23 @@ var init_inject = __esm({
     READ_TOOLS = /* @__PURE__ */ new Set(["read", "read_file", "readfile", "view"]);
     SHELL_TOOLS = /* @__PURE__ */ new Set(["bash", "shell", "run_shell_command", "local_shell", "exec_command"]);
     SHELL_META = /[|;&<>$`()]/;
-    sessionFile = (stateRoot, sessionId) => path22.join(injectStateDir(stateRoot), `${sessionId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+    sessionFile = (stateRoot2, sessionId) => path23.join(injectStateDir(stateRoot2), `${sessionId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
     MAX_SUPPRESSED_LOGGED = 10;
   }
 });
 
 // packages/core/dist/knowledge/migrate.js
-import fs22 from "fs";
-import path23 from "path";
+import fs23 from "fs";
+import path24 from "path";
 import { execFileSync as execFileSync6 } from "child_process";
 function findLegacyKbs(cfg) {
   const root = legacyRoot(cfg);
-  if (!fs22.existsSync(root))
+  if (!fs23.existsSync(root))
     return [];
-  return fs22.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && KB_NAME_RE.test(e.name)).map((e) => e.name).sort();
+  return fs23.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && KB_NAME_RE.test(e.name)).map((e) => e.name).sort();
 }
 function ensureGitRepo(dir) {
-  if (fs22.existsSync(path23.join(dir, ".git")))
+  if (fs23.existsSync(path24.join(dir, ".git")))
     return false;
   try {
     execFileSync6("git", ["init", "-q", dir], { stdio: "ignore" });
@@ -13555,14 +13643,14 @@ function ensureGitRepo(dir) {
   }
 }
 function ensureKbGitignore(dir) {
-  const file = path23.join(dir, ".gitignore");
-  if (fs22.existsSync(file))
+  const file = path24.join(dir, ".gitignore");
+  if (fs23.existsSync(file))
     return false;
-  fs22.writeFileSync(file, KB_GITIGNORE);
+  fs23.writeFileSync(file, KB_GITIGNORE);
   return true;
 }
 function findLegacyOverlays(cfg) {
-  return Object.keys(cfg.projects).filter((p) => fs22.existsSync(legacyOverlay(cfg, p))).sort();
+  return Object.keys(cfg.projects).filter((p) => fs23.existsSync(legacyOverlay(cfg, p))).sort();
 }
 function moveLegacyOverlays(cfg, opts = {}) {
   return findLegacyOverlays(cfg).map((project) => {
@@ -13571,18 +13659,18 @@ function moveLegacyOverlays(cfg, opts = {}) {
     const kb = `overlay:${project}`;
     if (!to)
       return { kb, from, to: "", action: "skipped", note: "no group KB or knowledgeHome for this project; set one, then re-run" };
-    if (fs22.existsSync(to))
+    if (fs23.existsSync(to))
       return { kb, from, to, action: "skipped", note: "target already exists; nothing moved" };
     if (opts.dryRun)
       return { kb, from, to, action: "would-move" };
-    fs22.mkdirSync(path23.dirname(to), { recursive: true });
+    fs23.mkdirSync(path24.dirname(to), { recursive: true });
     try {
-      fs22.renameSync(from, to);
+      fs23.renameSync(from, to);
       return { kb, from, to, action: "moved" };
     } catch (e) {
       if (e.code !== "EXDEV")
         throw e;
-      fs22.cpSync(from, to, { recursive: true });
+      fs23.cpSync(from, to, { recursive: true });
       return { kb, from, to, action: "copied", note: "cross-device: original left in place, delete it yourself once verified" };
     }
   });
@@ -13592,32 +13680,32 @@ function moveLegacyKbs(cfg, opts = {}) {
   return findLegacyKbs(cfg).map((kb) => {
     const from = legacyKbDir(hub, kb);
     const to = kbDir(cfg, kb);
-    if (fs22.existsSync(to))
+    if (fs23.existsSync(to))
       return { kb, from, to, action: "skipped", note: "target already exists; nothing moved" };
     if (opts.dryRun)
       return { kb, from, to, action: "would-move" };
-    fs22.mkdirSync(path23.dirname(to), { recursive: true });
+    fs23.mkdirSync(path24.dirname(to), { recursive: true });
     let action = "moved";
     try {
-      fs22.renameSync(from, to);
+      fs23.renameSync(from, to);
     } catch (e) {
       if (e.code !== "EXDEV")
         throw e;
-      fs22.cpSync(from, to, { recursive: true });
+      fs23.cpSync(from, to, { recursive: true });
       action = "copied";
     }
     const notes = [];
-    const oldRules = path23.join(to, "rules"), newRules = path23.join(to, "shared", "rules");
-    if (fs22.existsSync(oldRules) && !fs22.existsSync(newRules)) {
-      fs22.mkdirSync(path23.dirname(newRules), { recursive: true });
-      fs22.renameSync(oldRules, newRules);
+    const oldRules = path24.join(to, "rules"), newRules = path24.join(to, "shared", "rules");
+    if (fs23.existsSync(oldRules) && !fs23.existsSync(newRules)) {
+      fs23.mkdirSync(path24.dirname(newRules), { recursive: true });
+      fs23.renameSync(oldRules, newRules);
       notes.push("rules/ -> shared/rules/");
     }
     if (ensureGitRepo(to))
       notes.push("git init");
     if (ensureKbGitignore(to))
       notes.push("wrote .gitignore (raw/, .converted/)");
-    if (fs22.existsSync(path23.join(to, "index.json")))
+    if (fs23.existsSync(path24.join(to, "index.json")))
       notes.push(`index.json holds old paths: run squadrant knowledge reindex ${kb}`);
     if (action === "copied")
       notes.push("cross-device: original left in place, delete it yourself once verified");
@@ -13629,22 +13717,22 @@ var init_migrate = __esm({
   "packages/core/dist/knowledge/migrate.js"() {
     init_dist();
     init_paths();
-    legacyRoot = (cfg) => path23.join(resolveHome(cfg.hubVault), "knowledge");
+    legacyRoot = (cfg) => path24.join(resolveHome(cfg.hubVault), "knowledge");
     KB_GITIGNORE = "# squadrant KB defaults: source documents stay local\nraw/\n.converted/\n";
-    legacyOverlay = (cfg, project) => path23.join(resolveHome(cfg.projects[project].spokeVault), "knowledge", "rules");
+    legacyOverlay = (cfg, project) => path24.join(resolveHome(cfg.projects[project].spokeVault), "knowledge", "rules");
   }
 });
 
 // packages/core/dist/knowledge/errata.js
-import fs23 from "fs";
-import path24 from "path";
+import fs24 from "fs";
+import path25 from "path";
 function loadErrata(kbRoot) {
-  const file = path24.join(kbRoot, "errata.yaml");
-  if (!fs23.existsSync(file))
+  const file = path25.join(kbRoot, "errata.yaml");
+  if (!fs24.existsSync(file))
     return { errata: [], errors: [] };
   let data;
   try {
-    data = yaml.load(fs23.readFileSync(file, "utf8"), { schema: yaml.JSON_SCHEMA });
+    data = yaml.load(fs24.readFileSync(file, "utf8"), { schema: yaml.JSON_SCHEMA });
   } catch (e) {
     return { errata: [], errors: [`YAML parse error: ${e.message.split("\n")[0]}`] };
   }
@@ -13674,7 +13762,7 @@ function orphanedErrata(kbRoot, sources, errata, refs) {
       continue;
     if (!hays.has(ref)) {
       const conv = readState2(kbRoot, ref) ? convertedFile(kbRoot, ref) : null;
-      hays.set(ref, conv && fs23.existsSync(conv) ? normalizedViews(fs23.readFileSync(conv, "utf8")) : null);
+      hays.set(ref, conv && fs24.existsSync(conv) ? normalizedViews(fs24.readFileSync(conv, "utf8")) : null);
     }
     const hay = hays.get(ref);
     if (hay && !findQuote(hay, e.quote))
@@ -13692,9 +13780,9 @@ var init_errata = __esm({
 });
 
 // packages/core/dist/knowledge/anchor.js
-import fs24 from "fs";
+import fs25 from "fs";
 import { execFileSync as execFileSync7 } from "child_process";
-import path25 from "path";
+import path26 from "path";
 function gitFiles(root) {
   try {
     const out = execFileSync7("git", ["ls-files", "-co", "--exclude-standard", "-z"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
@@ -13708,13 +13796,13 @@ function* repoFiles(root, maxFiles) {
   const listed = gitFiles(root);
   if (listed) {
     for (const rel of listed) {
-      if (!CODE_EXT.has(path25.extname(rel)) || rel.split("/").slice(0, -1).some((d) => SKIP_DIRS.has(d)))
+      if (!CODE_EXT.has(path26.extname(rel)) || rel.split("/").slice(0, -1).some((d) => SKIP_DIRS.has(d)))
         continue;
       if (++count > maxFiles) {
         console.warn(`anchor: ${root} has more than ${maxFiles} code files; anchors cover only the first ${maxFiles}`);
         return;
       }
-      yield path25.join(root, rel);
+      yield path26.join(root, rel);
     }
     return;
   }
@@ -13723,20 +13811,20 @@ function* repoFiles(root, maxFiles) {
     const dir = stack.pop();
     let ents;
     try {
-      ents = fs24.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? 1 : -1);
+      ents = fs25.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? 1 : -1);
     } catch {
       continue;
     }
     for (const ent of ents) {
       if (ent.isDirectory()) {
         if (!SKIP_DIRS.has(ent.name))
-          stack.push(path25.join(dir, ent.name));
-      } else if (ent.isFile() && CODE_EXT.has(path25.extname(ent.name))) {
+          stack.push(path26.join(dir, ent.name));
+      } else if (ent.isFile() && CODE_EXT.has(path26.extname(ent.name))) {
         if (++count > maxFiles) {
           console.warn(`anchor: ${root} has more than ${maxFiles} code files; anchors cover only the first ${maxFiles}`);
           return;
         }
-        yield path25.join(dir, ent.name);
+        yield path26.join(dir, ent.name);
       }
     }
   }
@@ -13745,11 +13833,11 @@ function scanRepo(root, maxFiles) {
   const out = [];
   for (const file of repoFiles(root, maxFiles)) {
     try {
-      if (fs24.statSync(file).size > MAX_FILE_BYTES)
+      if (fs25.statSync(file).size > MAX_FILE_BYTES)
         continue;
-      const text = fs24.readFileSync(file, "utf8");
-      const rel = path25.relative(root, file).split(path25.sep).join("/");
-      out.push({ rel, text, hay: `${path25.relative(root, file)}
+      const text = fs25.readFileSync(file, "utf8");
+      const rel = path26.relative(root, file).split(path26.sep).join("/");
+      out.push({ rel, text, hay: `${path26.relative(root, file)}
 ${text}`.toLowerCase() });
     } catch {
       continue;
@@ -13759,7 +13847,7 @@ ${text}`.toLowerCase() });
 }
 function computeAnchor(repoRoot, triggers, cache, maxFiles = MAX_FILES) {
   const terms2 = anchorTerms(triggers);
-  if (!terms2.length || !fs24.existsSync(repoRoot))
+  if (!terms2.length || !fs25.existsSync(repoRoot))
     return null;
   let files = cache?.get(repoRoot);
   if (!files) {
@@ -13795,8 +13883,8 @@ var init_anchor = __esm({
 });
 
 // packages/core/dist/knowledge/extract.js
-import fs25 from "fs";
-import path26 from "path";
+import fs26 from "fs";
+import path27 from "path";
 import matter4 from "gray-matter";
 function serialize(fm, body) {
   return matter4.stringify(body.trim() + "\n", clean(fm));
@@ -13864,13 +13952,13 @@ function applyCandidates(input, opts) {
     }
     const st = readState2(kbRoot, cand.source);
     const convFile = st ? convertedFile(kbRoot, cand.source) : null;
-    if (!st || !fs25.existsSync(convFile)) {
+    if (!st || !fs26.existsSync(convFile)) {
       res.rejected.push({ id: cand.id, source: cand.source, reason: "unknown source (not ingested)" });
       continue;
     }
     let hay = norm.get(cand.source);
     if (!hay) {
-      hay = normalizedViews(fs25.readFileSync(convFile, "utf8"));
+      hay = normalizedViews(fs26.readFileSync(convFile, "utf8"));
       norm.set(cand.source, hay);
     }
     const tot = totals.get(cand.source) ?? { total: 0, dropped: 0 };
@@ -13932,7 +14020,7 @@ ${cand.rationale.trim()}` : "");
         supersedes: [],
         conflictsWith: []
       };
-      work.set(id, { fm: fm2, body: bodyOf(), file: path26.join(rulesDir, cand.domain, `${id}.md`), dirty: true, isNew: true });
+      work.set(id, { fm: fm2, body: bodyOf(), file: path27.join(rulesDir, cand.domain, `${id}.md`), dirty: true, isNew: true });
       res.created.push(id);
       ev2("item.applied", id);
       continue;
@@ -13949,24 +14037,24 @@ ${cand.rationale.trim()}` : "");
       supersedes: [],
       conflictsWith: contradicted
     };
-    const dir = path26.join(rulesDir, PROPOSED_DIR);
-    const file = path26.join(dir, `${id}@${st.sha.slice(0, SHA_LEN)}.md`);
+    const dir = path27.join(rulesDir, PROPOSED_DIR);
+    const file = path27.join(dir, `${id}@${st.sha.slice(0, SHA_LEN)}.md`);
     const text = serialize(fm, bodyOf());
-    if (fs25.existsSync(file) && fs25.readFileSync(file, "utf8") === text)
+    if (fs26.existsSync(file) && fs26.readFileSync(file, "utf8") === text)
       continue;
-    fs25.mkdirSync(dir, { recursive: true });
-    for (const other of fs25.readdirSync(dir)) {
-      if (!other.startsWith(`${id}@`) || !other.endsWith(".md") || path26.join(dir, other) === file)
+    fs26.mkdirSync(dir, { recursive: true });
+    for (const other of fs26.readdirSync(dir)) {
+      if (!other.startsWith(`${id}@`) || !other.endsWith(".md") || path27.join(dir, other) === file)
         continue;
-      const old = matter4(fs25.readFileSync(path26.join(dir, other), "utf8"));
+      const old = matter4(fs26.readFileSync(path27.join(dir, other), "utf8"));
       if (!old.data.sources?.some((s) => canon(s.ref) === canon(cand.source)))
         continue;
-      fs25.writeFileSync(path26.join(dir, other.replace(/\.md$/, ".superseded")), matter4.stringify(old.content, { ...old.data, supersededBy: path26.basename(file) }));
-      fs25.rmSync(path26.join(dir, other));
+      fs26.writeFileSync(path27.join(dir, other.replace(/\.md$/, ".superseded")), matter4.stringify(old.content, { ...old.data, supersededBy: path27.basename(file) }));
+      fs26.rmSync(path27.join(dir, other));
       res.superseded.push(other.replace(/\.md$/, ""));
       ev2("item.superseded", id);
     }
-    fs25.writeFileSync(file, text);
+    fs26.writeFileSync(file, text);
     res.proposed.push(`${id}@${st.sha.slice(0, SHA_LEN)}`);
     ev2("item.proposed", id);
   }
@@ -13995,10 +14083,10 @@ ${cand.rationale.trim()}` : "");
   for (const w of work.values()) {
     if (!w.dirty)
       continue;
-    fs25.mkdirSync(path26.dirname(w.file), { recursive: true });
+    fs26.mkdirSync(path27.dirname(w.file), { recursive: true });
     const text = serialize(w.fm, w.body);
-    if (!fs25.existsSync(w.file) || fs25.readFileSync(w.file, "utf8") !== text)
-      fs25.writeFileSync(w.file, text);
+    if (!fs26.existsSync(w.file) || fs26.readFileSync(w.file, "utf8") !== text)
+      fs26.writeFileSync(w.file, text);
   }
   res.orphanedErrata = orphanedErrata(kbRoot, opts.sources ?? [], opts.errata ?? [], totals.keys());
   for (const [ref, t] of totals)
@@ -14034,20 +14122,20 @@ var init_extract = __esm({
 });
 
 // packages/core/dist/knowledge/schedule.js
-import fs26 from "fs";
-import path27 from "path";
-function readSchedule(stateRoot) {
+import fs27 from "fs";
+import path28 from "path";
+function readSchedule(stateRoot2) {
   try {
-    return JSON.parse(fs26.readFileSync(scheduleFile(stateRoot), "utf8"));
+    return JSON.parse(fs27.readFileSync(scheduleFile(stateRoot2), "utf8"));
   } catch {
     return {};
   }
 }
-function writeSchedule(stateRoot, s) {
-  fs26.mkdirSync(stateRoot, { recursive: true });
-  const tmp = `${scheduleFile(stateRoot)}.${process.pid}.tmp`;
-  fs26.writeFileSync(tmp, JSON.stringify(s, null, 2) + "\n");
-  fs26.renameSync(tmp, scheduleFile(stateRoot));
+function writeSchedule(stateRoot2, s) {
+  fs27.mkdirSync(stateRoot2, { recursive: true });
+  const tmp = `${scheduleFile(stateRoot2)}.${process.pid}.tmp`;
+  fs27.writeFileSync(tmp, JSON.stringify(s, null, 2) + "\n");
+  fs27.renameSync(tmp, scheduleFile(stateRoot2));
 }
 function snapshotSources(kbRoot, sources) {
   const out = {};
@@ -14127,7 +14215,7 @@ async function tickKnowledgeSchedule(d) {
       continue;
     try {
       const root = kbDir(d.cfg, kb);
-      if (!fs26.existsSync(root))
+      if (!fs27.existsSync(root))
         continue;
       const { sources } = loadSources(root);
       if (!sources.length)
@@ -14192,7 +14280,7 @@ var init_schedule = __esm({
     init_sources();
     RUNNING_STALE_MS = 6 * 60 * 60 * 1e3;
     DAY_MS = 24 * 60 * 60 * 1e3;
-    scheduleFile = (stateRoot) => path27.join(stateRoot, "knowledge-schedule.json");
+    scheduleFile = (stateRoot2) => path28.join(stateRoot2, "knowledge-schedule.json");
     reconcileConfig = (cfg, kb) => ({ ...DEFAULT_RECONCILE, ...kbConfigs(cfg)[kb]?.reconcile });
   }
 });
@@ -14200,19 +14288,19 @@ var init_schedule = __esm({
 // packages/core/dist/knowledge/review.js
 import crypto4 from "crypto";
 import { execFileSync as execFileSync8 } from "child_process";
-import fs27 from "fs";
-import path28 from "path";
+import fs28 from "fs";
+import path29 from "path";
 import matter5 from "gray-matter";
 function readEscalations(kbRoot) {
   try {
-    return JSON.parse(fs27.readFileSync(escalationsFile(kbRoot), "utf8")).items;
+    return JSON.parse(fs28.readFileSync(escalationsFile(kbRoot), "utf8")).items;
   } catch {
     return [];
   }
 }
 function writeEscalations(kbRoot, items) {
-  fs27.mkdirSync(kbRoot, { recursive: true });
-  fs27.writeFileSync(escalationsFile(kbRoot), JSON.stringify({ items }, null, 2) + "\n");
+  fs28.mkdirSync(kbRoot, { recursive: true });
+  fs28.writeFileSync(escalationsFile(kbRoot), JSON.stringify({ items }, null, 2) + "\n");
 }
 function addEscalation(kbRoot, e) {
   const items = readEscalations(kbRoot);
@@ -14222,8 +14310,8 @@ function addEscalation(kbRoot, e) {
   return true;
 }
 function appendVerdict(kbRoot, v2, now) {
-  fs27.mkdirSync(kbRoot, { recursive: true });
-  fs27.appendFileSync(verdictsFile(kbRoot), JSON.stringify({ ts: now.toISOString(), ...v2 }) + "\n");
+  fs28.mkdirSync(kbRoot, { recursive: true });
+  fs28.appendFileSync(verdictsFile(kbRoot), JSON.stringify({ ts: now.toISOString(), ...v2 }) + "\n");
 }
 function priorityOfRef(c, ref) {
   if (ref.startsWith("agent:"))
@@ -14240,20 +14328,20 @@ function loadProposals(c) {
   const byId = new Map(live.map((r) => [r.id, r]));
   const proposals = [];
   const pdirs = /* @__PURE__ */ new Set();
-  for (const f of fs27.existsSync(dir) ? walkDirs(dir) : [])
-    if (path28.basename(f) === PROPOSED_DIR)
+  for (const f of fs28.existsSync(dir) ? walkDirs(dir) : [])
+    if (path29.basename(f) === PROPOSED_DIR)
       pdirs.add(f);
   for (const pd of pdirs) {
     for (const rule of loadRulesDir(pd, `kb:${c.kb}`, { includeProposed: true }).rules) {
-      proposals.push({ key: path28.basename(rule.file).replace(/\.md$/, ""), rule, live: byId.get(rule.id) });
+      proposals.push({ key: path29.basename(rule.file).replace(/\.md$/, ""), rule, live: byId.get(rule.id) });
     }
   }
   return { proposals, live };
 }
 function walkDirs(dir, out = []) {
-  for (const e of fs27.readdirSync(dir, { withFileTypes: true }))
+  for (const e of fs28.readdirSync(dir, { withFileTypes: true }))
     if (e.isDirectory()) {
-      const f = path28.join(dir, e.name);
+      const f = path29.join(dir, e.name);
       out.push(f);
       walkDirs(f, out);
     }
@@ -14282,7 +14370,7 @@ function promoteProposal(c, p, by, justification, events) {
       continue;
     const o = readFm(other.file);
     o.fm.status = "retired";
-    fs27.writeFileSync(other.file, fileText(o.fm, o.body));
+    fs28.writeFileSync(other.file, fileText(o.fm, o.body));
     retired.push(id);
     events.push(ev(c, "item.superseded", id));
   }
@@ -14292,16 +14380,16 @@ function promoteProposal(c, p, by, justification, events) {
   const anchors = anchorsFor(c, { ...next, anchors: p.live?.anchors ?? fm.anchors });
   if (anchors)
     next.anchors = anchors;
-  const target = p.live?.file ?? path28.join(dir, next.domain, `${next.id}.md`);
-  fs27.mkdirSync(path28.dirname(target), { recursive: true });
-  fs27.writeFileSync(target, fileText(next, body));
-  fs27.rmSync(p.rule.file);
+  const target = p.live?.file ?? path29.join(dir, next.domain, `${next.id}.md`);
+  fs28.mkdirSync(path29.dirname(target), { recursive: true });
+  fs28.writeFileSync(target, fileText(next, body));
+  fs28.rmSync(p.rule.file);
   events.push(ev(c, "item.approved", next.id), ev(c, "item.applied", next.id));
   if (p.live)
     events.push(ev(c, "item.superseded", next.id));
 }
 function dropProposal(c, p, events) {
-  fs27.rmSync(p.rule.file);
+  fs28.rmSync(p.rule.file);
   events.push(ev(c, "item.rejected", p.rule.id, { reason: "reviewer" }));
 }
 function mergeInto(c, p, targetId, live, events) {
@@ -14313,8 +14401,8 @@ function mergeInto(c, p, targetId, live, events) {
   for (const s of p.rule.sources)
     if (!tf.fm.sources.some((x) => canon(x.ref) === canon(s.ref)))
       tf.fm.sources.push(s);
-  fs27.writeFileSync(t.file, fileText(tf.fm, tf.body));
-  fs27.rmSync(p.rule.file);
+  fs28.writeFileSync(t.file, fileText(tf.fm, tf.body));
+  fs28.rmSync(p.rule.file);
   events.push(ev(c, "item.superseded", p.rule.id), ev(c, "item.applied", targetId));
   return true;
 }
@@ -14374,6 +14462,7 @@ function applyDecisions(file, c) {
       if (v2.action === "flag-violation") {
         escalate({ key: `violation:${target.id}`, kind: "code-violation", ruleId: target.id, reasons: ["doc newer than code"], explanation: v2.explanation, needsYou: false });
         res.violations.push(target.id);
+        events.push(ev(c, "item.outcome", target.id, { outcome: "violated", source: "reconcile", project: d.codeConflict.project }));
       } else if (v2.action === "escalate") {
         escalate({ key: `code-vs-doc:${target.id}`, kind: "code-vs-doc", ruleId: target.id, reasons: ["code-vs-doc"], explanation: v2.explanation, evidence: v2.evidence, confidence: conf });
         verdict(d, "escalated", { reasons: ["code-vs-doc"], confidence: conf });
@@ -14392,7 +14481,7 @@ function applyDecisions(file, c) {
           f.fm.sources[0].loc = d.loc;
         const noSource = !rule.sources.length;
         if (conf >= threshold && !d.flag && !reasons.length && !noSource) {
-          fs27.writeFileSync(rule.file, fileText(f.fm, f.body));
+          fs28.writeFileSync(rule.file, fileText(f.fm, f.body));
           res.applied.push(d.item);
           events.push(ev(c, "item.applied", rule.id));
           verdict(d, "applied", { confidence: conf });
@@ -14409,7 +14498,7 @@ function applyDecisions(file, c) {
         if (!reasons.length) {
           const f = readFm(rule.file);
           f.fm.status = "retired";
-          fs27.writeFileSync(rule.file, fileText(f.fm, f.body));
+          fs28.writeFileSync(rule.file, fileText(f.fm, f.body));
           res.applied.push(d.item);
           events.push(ev(c, "item.archived", rule.id));
           verdict(d, "applied", { confidence: conf });
@@ -14489,7 +14578,7 @@ function applyPair(pd, c, res, threshold, events, kbRoot, now) {
     for (const [x, y] of [[a, b], [b, a]]) {
       const f = readFm(x.file);
       f.fm.conflictsWith = [.../* @__PURE__ */ new Set([...f.fm.conflictsWith ?? [], y.id])];
-      fs27.writeFileSync(x.file, fileText(f.fm, f.body));
+      fs28.writeFileSync(x.file, fileText(f.fm, f.body));
     }
     return;
   }
@@ -14505,10 +14594,10 @@ function applyPair(pd, c, res, threshold, events, kbRoot, now) {
     if (!kf.fm.sources.some((x) => canon(x.ref) === canon(s.ref)))
       kf.fm.sources.push(s);
   kf.fm.supersedes = [.../* @__PURE__ */ new Set([...kf.fm.supersedes ?? [], drop.id])];
-  fs27.writeFileSync(keep.file, fileText(kf.fm, kf.body));
+  fs28.writeFileSync(keep.file, fileText(kf.fm, kf.body));
   const df = readFm(drop.file);
   df.fm.status = "retired";
-  fs27.writeFileSync(drop.file, fileText(df.fm, df.body));
+  fs28.writeFileSync(drop.file, fileText(df.fm, df.body));
   events.push(ev(c, "item.superseded", drop.id), ev(c, "item.applied", keep.id));
   res.applied.push(key);
 }
@@ -14541,7 +14630,7 @@ function resolveEscalation(c, key, r, by, reason) {
       f.fm.status = "retired";
       events.push(ev(c, "item.superseded", rule.id));
     }
-    fs27.writeFileSync(rule.file, fileText(f.fm, f.body));
+    fs28.writeFileSync(rule.file, fileText(f.fm, f.body));
     return done(`${rule.id}: ${r.verdict}`);
   }
   if (esc.kind === "proposal") {
@@ -14564,20 +14653,20 @@ function resolveEscalation(c, key, r, by, reason) {
     if (rule) {
       const f = readFm(rule.file);
       f.fm.status = r.kind === "approve" ? "retired" : "active";
-      fs27.writeFileSync(rule.file, fileText(f.fm, f.body));
+      fs28.writeFileSync(rule.file, fileText(f.fm, f.body));
       events.push(ev(c, r.kind === "approve" ? "item.archived" : "item.applied", rule.id));
     }
     return done(`${esc.ruleId}: ${r.kind === "approve" ? "retired" : "kept"}`);
   }
   if (esc.kind === "override-base-changed") {
-    const ov = esc.item && fs27.existsSync(esc.item) ? esc.item : void 0;
+    const ov = esc.item && fs28.existsSync(esc.item) ? esc.item : void 0;
     if (ov) {
       if (r.kind === "reject")
-        fs27.rmSync(ov);
+        fs28.rmSync(ov);
       else {
         const f = readFm(ov);
         f.fm.overridesBase = esc.evidence?.docRev;
-        fs27.writeFileSync(ov, fileText(f.fm, f.body));
+        fs28.writeFileSync(ov, fileText(f.fm, f.body));
       }
     }
     return done(`${esc.ruleId}: override ${r.kind === "reject" ? "dropped" : "kept"}`);
@@ -14601,10 +14690,10 @@ ${o.evidence}`).digest("hex");
     supersedes: [],
     conflictsWith: []
   };
-  const dir = path28.join(kbRulesDir(c.cfg, c.kb), PROPOSED_DIR);
-  fs27.mkdirSync(dir, { recursive: true });
-  const file = path28.join(dir, `${id}@${sha.slice(0, SHA_LEN2)}.md`);
-  fs27.writeFileSync(file, fileText(fm, o.statement));
+  const dir = path29.join(kbRulesDir(c.cfg, c.kb), PROPOSED_DIR);
+  fs28.mkdirSync(dir, { recursive: true });
+  const file = path29.join(dir, `${id}@${sha.slice(0, SHA_LEN2)}.md`);
+  fs28.writeFileSync(file, fileText(fm, o.statement));
   appendAudit([ev(c, "item.proposed", id)], c.audit);
   return file;
 }
@@ -14645,8 +14734,8 @@ var init_review = __esm({
     PRIORITY_RANK = { company: 3, project: 2, agent: 1 };
     SHA_LEN2 = 12;
     strong = (m) => m === "must" || m === "must-not";
-    escalationsFile = (kbRoot) => path28.join(kbRoot, "escalations.json");
-    verdictsFile = (kbRoot) => path28.join(kbRoot, "verdicts.jsonl");
+    escalationsFile = (kbRoot) => path29.join(kbRoot, "escalations.json");
+    verdictsFile = (kbRoot) => path29.join(kbRoot, "verdicts.jsonl");
     needsYouCount = (kbRoot) => readEscalations(kbRoot).filter((e) => e.needsYou).length;
     git = (root, args) => execFileSync8("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     realGit = {
@@ -14667,13 +14756,13 @@ var init_review = __esm({
       },
       docDate(file) {
         try {
-          const d = git(path28.dirname(file), ["log", "-1", "--format=%cI", "--", path28.basename(file)]);
+          const d = git(path29.dirname(file), ["log", "-1", "--format=%cI", "--", path29.basename(file)]);
           if (d)
             return d;
         } catch {
         }
         try {
-          return fs27.statSync(file).mtime.toISOString();
+          return fs28.statSync(file).mtime.toISOString();
         } catch {
           return null;
         }
@@ -14682,7 +14771,7 @@ var init_review = __esm({
     nowOf = (c) => c.now?.() ?? /* @__PURE__ */ new Date();
     fileText = (fm, body) => matter5.stringify(body.trim() + "\n", JSON.parse(JSON.stringify(fm)));
     readFm = (file) => {
-      const m = matter5(fs27.readFileSync(file, "utf8"));
+      const m = matter5(fs28.readFileSync(file, "utf8"));
       return { fm: m.data, body: m.content };
     };
     ev = (c, event, itemId, extra = {}) => ({ kb: c.kb, level: "group", project: "", domain: "rules", itemId, event, ...extra });
@@ -14692,8 +14781,8 @@ var init_review = __esm({
 
 // packages/core/dist/knowledge/fullpass.js
 import crypto5 from "crypto";
-import fs28 from "fs";
-import path29 from "path";
+import fs29 from "fs";
+import path30 from "path";
 import matter6 from "gray-matter";
 function dedupPairs(rules) {
   const active = rules.filter((r) => r.status === "active").sort((x, y) => x.id.localeCompare(y.id));
@@ -14710,12 +14799,12 @@ function dedupPairs(rules) {
   return out.slice(0, MAX_DEDUP_PAIRS);
 }
 function readAuditRecords(kb, since, dir = defaultAuditDir()) {
-  if (!fs28.existsSync(dir))
+  if (!fs29.existsSync(dir))
     return [];
   const sinceMonth = since.toISOString().slice(0, 7);
   const out = [];
-  for (const f of fs28.readdirSync(dir).filter((n) => n.endsWith(".jsonl") && n.slice(0, 7) >= sinceMonth).sort()) {
-    for (const line2 of fs28.readFileSync(path29.join(dir, f), "utf8").split("\n")) {
+  for (const f of fs29.readdirSync(dir).filter((n) => n.endsWith(".jsonl") && n.slice(0, 7) >= sinceMonth).sort()) {
+    for (const line2 of fs29.readFileSync(path30.join(dir, f), "utf8").split("\n")) {
       if (!line2.trim())
         continue;
       try {
@@ -14737,7 +14826,7 @@ function usageReview(rules, events) {
       continue;
     if (e.event === "item.surfaced")
       surfaced[e.itemId] = (surfaced[e.itemId] ?? 0) + 1;
-    if (e.event === "item.outcome") {
+    if (e.event === "item.outcome" && RATED_SOURCES.has(outcomeSource(e))) {
       if (e.outcome === "noise")
         noise[e.itemId] = (noise[e.itemId] ?? 0) + 1;
       if (e.outcome === "violated")
@@ -14778,8 +14867,8 @@ function checkOverrides(cfg, kb) {
         continue;
       const h = baseHash(b);
       if (!o.overridesBase) {
-        const m = matter6(fs28.readFileSync(o.file, "utf8"));
-        fs28.writeFileSync(o.file, matter6.stringify(m.content, { ...m.data, overridesBase: h }));
+        const m = matter6(fs29.readFileSync(o.file, "utf8"));
+        fs29.writeFileSync(o.file, matter6.stringify(m.content, { ...m.data, overridesBase: h }));
         continue;
       }
       out.push({ project, ruleId: o.id, file: o.file, baseHash: h, changed: o.overridesBase !== h });
@@ -14822,8 +14911,8 @@ var init_fullpass = __esm({
 });
 
 // packages/core/dist/knowledge/scores.js
-import fs29 from "fs";
-import path30 from "path";
+import fs30 from "fs";
+import path31 from "path";
 function tally(records, into = emptyTally()) {
   for (const e of records) {
     const domain = typeof e.domain === "string" && e.domain ? e.domain : "rules";
@@ -14859,17 +14948,25 @@ function tally(records, into = emptyTally()) {
         c.cited++;
         c.lastUsed = later(c.lastUsed, e.ts);
         break;
-      case "item.outcome":
-        if (OUTCOMES.has(String(e.outcome)))
-          c[e.outcome]++;
+      case "item.outcome": {
+        if (!OUTCOMES.has(String(e.outcome)))
+          break;
+        const src = outcomeSource(e), o = e.outcome;
+        const bySrc = into.sources[src] ??= {};
+        bySrc[o] = (bySrc[o] ?? 0) + 1;
+        if (src === "reconcile" && o === "violated")
+          c.codeViolations++;
+        else if (RATED_SOURCES.has(src))
+          c[o]++;
         break;
+      }
     }
   }
   return into;
 }
 function parseLines(file) {
   const out = [];
-  for (const line2 of fs29.readFileSync(file, "utf8").split("\n")) {
+  for (const line2 of fs30.readFileSync(file, "utf8").split("\n")) {
     if (!line2.trim())
       continue;
     try {
@@ -14881,37 +14978,37 @@ function parseLines(file) {
 }
 function compactAudit(o) {
   const dir = o.dir ?? defaultAuditDir();
-  if (!fs29.existsSync(dir))
+  if (!fs30.existsSync(dir))
     return [];
   const cutoffMonth = new Date(o.now.getTime() - SCORE_WINDOW_DAYS * DAY_MS3).toISOString().slice(0, 7);
   const done = [];
-  for (const f of fs29.readdirSync(dir).sort()) {
+  for (const f of fs30.readdirSync(dir).sort()) {
     const m = MONTH_FILE_RE.exec(f);
     if (!m || m[1] >= cutoffMonth)
       continue;
     const [, month, machine] = m;
     const byKb = /* @__PURE__ */ new Map();
-    for (const r of parseLines(path30.join(dir, f)))
+    for (const r of parseLines(path31.join(dir, f)))
       byKb.set(r.kb ?? "", [...byKb.get(r.kb ?? "") ?? [], r]);
-    const statsPath = path30.join(dir, statsFileName(month, machine));
-    const prior = fs29.existsSync(statsPath) ? JSON.parse(fs29.readFileSync(statsPath, "utf8")) : null;
+    const statsPath = path31.join(dir, statsFileName(month, machine));
+    const prior = fs30.existsSync(statsPath) ? JSON.parse(fs30.readFileSync(statsPath, "utf8")) : null;
     const kbs = prior?.kbs ?? {};
     for (const [kb, recs] of byKb)
       kbs[kb] = tally(recs, kbs[kb]);
-    fs29.writeFileSync(`${statsPath}.tmp`, JSON.stringify({ month, machine, kbs }));
-    fs29.renameSync(`${statsPath}.tmp`, statsPath);
-    fs29.unlinkSync(path30.join(dir, f));
+    fs30.writeFileSync(`${statsPath}.tmp`, JSON.stringify({ month, machine, kbs }));
+    fs30.renameSync(`${statsPath}.tmp`, statsPath);
+    fs30.unlinkSync(path31.join(dir, f));
     done.push(month);
   }
   return done;
 }
 function readCompacted(kb, dir) {
   const t = emptyTally();
-  if (!fs29.existsSync(dir))
+  if (!fs30.existsSync(dir))
     return t;
-  for (const f of fs29.readdirSync(dir).filter((n) => n.endsWith(".stats.json"))) {
+  for (const f of fs30.readdirSync(dir).filter((n) => n.endsWith(".stats.json"))) {
     try {
-      const k = JSON.parse(fs29.readFileSync(path30.join(dir, f), "utf8")).kbs[kb];
+      const k = JSON.parse(fs30.readFileSync(path31.join(dir, f), "utf8")).kbs[kb];
       if (k)
         mergeTally(t, k);
     } catch {
@@ -14937,6 +15034,12 @@ function mergeTally(into, from) {
     into.agents[k] = (into.agents[k] ?? 0) + v2;
   for (const [k, v2] of Object.entries(from.tiers))
     into.tiers[k] = (into.tiers[k] ?? 0) + v2;
+  into.sources ??= {};
+  for (const [src, os18] of Object.entries(from.sources ?? {})) {
+    const t = into.sources[src] ??= {};
+    for (const [o, n] of Object.entries(os18))
+      t[o] = (t[o] ?? 0) + n;
+  }
 }
 function computeScores(i) {
   const since = i.now.getTime() - SCORE_WINDOW_DAYS * DAY_MS3;
@@ -14960,11 +15063,14 @@ function computeScores(i) {
       violated: w.violated,
       noise: w.noise,
       wrong: w.wrong,
+      codeViolations: w.codeViolations,
+      evaluated: w.followed + w.violated,
       fireRate: w.surfaced,
       pullRate: w.shown + w.searched,
       useRate: ratio(w.cited, w.surfaced),
       noiseRate: ratio(w.noise, w.surfaced),
       violationRate: ratio(w.violated, w.surfaced),
+      complianceRate: w.followed + w.violated >= COMPLIANCE_MIN_EVALUATED ? ratio(w.followed, w.followed + w.violated) : null,
       lastSurfaced: l?.lastSurfaced,
       lastUsed: l?.lastUsed,
       neverFired30d: w.surfaced === 0 && (knownActive.has(key) || (l?.surfaced ?? 0) > 0),
@@ -14997,53 +15103,58 @@ function computeScores(i) {
     domains,
     perAgentCoverage: win.agents,
     tierContribution: win.tiers,
-    reviewerAgreement: { resolved: operator.length, approved, rate: ratio(approved, operator.length) }
+    reviewerAgreement: { resolved: operator.length, approved, rate: ratio(approved, operator.length) },
+    bySource: win.sources
   };
 }
 function scoreKb(o) {
   const dir = o.auditDir ?? defaultAuditDir();
   const records = [];
-  if (fs29.existsSync(dir)) {
-    for (const f of fs29.readdirSync(dir).filter((n) => MONTH_FILE_RE.test(n)).sort()) {
-      records.push(...parseLines(path30.join(dir, f)).filter((r) => r.kb === o.kb));
+  if (fs30.existsSync(dir)) {
+    for (const f of fs30.readdirSync(dir).filter((n) => MONTH_FILE_RE.test(n)).sort()) {
+      records.push(...parseLines(path31.join(dir, f)).filter((r) => r.kb === o.kb));
     }
   }
   let verdicts = [];
   try {
-    verdicts = fs29.readFileSync(path30.join(o.kbRoot, "verdicts.jsonl"), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+    verdicts = fs30.readFileSync(path31.join(o.kbRoot, "verdicts.jsonl"), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
   } catch {
   }
   return computeScores({ kb: o.kb, records, now: o.now, known: o.known, compacted: readCompacted(o.kb, dir), verdicts });
 }
 function writeScores(kbRoot, s) {
-  fs29.mkdirSync(kbRoot, { recursive: true });
-  fs29.writeFileSync(scoresFile(kbRoot), JSON.stringify(s, null, 2) + "\n");
+  fs30.mkdirSync(kbRoot, { recursive: true });
+  fs30.writeFileSync(scoresFile(kbRoot), JSON.stringify(s, null, 2) + "\n");
 }
 function renderScoresSection(s) {
   const pct = (x) => x === null ? "n/a" : `${Math.round(x * 100)}%`;
   const used = s.items.filter((x) => x.surfaced).sort((a, b) => b.surfaced - a.surfaced || a.itemId.localeCompare(b.itemId)).slice(0, 10);
   const never = s.items.filter((x) => x.neverFired30d).map((x) => x.itemId);
+  const code = s.items.filter((x) => x.codeViolations).map((x) => `${x.itemId} ${x.codeViolations}`);
+  const sources = Object.keys(s.bySource).sort().map((src) => `${src} ${Object.entries(s.bySource[src]).map(([o, n]) => `${o} ${n}`).join(", ")}`);
   return [
     "",
     `## Scores (${s.windowDays} days)`,
     "",
     ...used.length ? [
-      "| Item | Surfaced | Pulled | Cited | Use | Noise | Violated |",
-      "|---|---|---|---|---|---|---|",
-      ...used.map((x) => `| ${x.itemId} | ${x.surfaced} | ${x.pullRate} | ${x.cited} | ${pct(x.useRate)} | ${pct(x.noiseRate)} | ${pct(x.violationRate)} |`)
+      "| Item | Surfaced | Pulled | Cited | Use | Noise | Violated | Compliance |",
+      "|---|---|---|---|---|---|---|---|",
+      ...used.map((x) => `| ${x.itemId} | ${x.surfaced} | ${x.pullRate} | ${x.cited} | ${pct(x.useRate)} | ${pct(x.noiseRate)} | ${pct(x.violationRate)} | ${pct(x.complianceRate)} |`)
     ] : ["No items surfaced."],
     "",
     `- Never fired (${never.length}): ${never.slice(0, 20).join(", ") || "none"}${never.length > 20 ? ", \u2026" : ""}`,
     `- Tier contribution: ${Object.entries(s.tierContribution).map(([k, v2]) => `${k} ${v2}`).join(", ") || "none"}`,
     `- Per-agent coverage (surfaced): ${Object.entries(s.perAgentCoverage).map(([k, v2]) => `${k} ${v2}`).join(", ") || "none"}`,
     `- Reviewer agreement: ${pct(s.reviewerAgreement.rate)} (${s.reviewerAgreement.approved}/${s.reviewerAgreement.resolved} operator resolutions approved)`,
+    `- Outcomes by source: ${sources.join("; ") || "none"} (crew and reconcile are not in the rates)`,
+    `- Code violations (reconcile, not in rates): ${code.join(", ") || "none"}`,
     "",
     "| Domain | Writes/mo | Reads/mo | Chars per citation | Alarm |",
     "|---|---|---|---|---|",
     ...s.domains.map((d) => `| ${d.domain} | ${d.writesPerMonth} | ${d.readsPerMonth} | ${d.charsPerCitation ?? "n/a"} | ${d.deadDomain ? "DEAD (no activity 30d)" : ""} |`)
   ];
 }
-var DAY_MS3, SCORE_WINDOW_DAYS, WRITE_EVENTS, READ_EVENTS, OUTCOMES, zero, later, emptyTally, MONTH_FILE_RE, statsFileName, ratio, scoresFile;
+var DAY_MS3, SCORE_WINDOW_DAYS, WRITE_EVENTS, READ_EVENTS, OUTCOMES, zero, later, emptyTally, MONTH_FILE_RE, statsFileName, ratio, COMPLIANCE_MIN_EVALUATED, scoresFile;
 var init_scores = __esm({
   "packages/core/dist/knowledge/scores.js"() {
     init_audit();
@@ -15052,19 +15163,20 @@ var init_scores = __esm({
     WRITE_EVENTS = /* @__PURE__ */ new Set(["item.proposed", "item.approved", "item.rejected", "item.applied", "item.promoted", "item.superseded", "item.archived"]);
     READ_EVENTS = /* @__PURE__ */ new Set(["item.surfaced", "item.shown", "item.searched"]);
     OUTCOMES = /* @__PURE__ */ new Set(["followed", "violated", "noise", "wrong"]);
-    zero = () => ({ surfaced: 0, suppressed: 0, searched: 0, shown: 0, cited: 0, followed: 0, violated: 0, noise: 0, wrong: 0, chars: 0 });
+    zero = () => ({ surfaced: 0, suppressed: 0, searched: 0, shown: 0, cited: 0, followed: 0, violated: 0, noise: 0, wrong: 0, codeViolations: 0, chars: 0 });
     later = (a, b) => a && b ? a > b ? a : b : a ?? b;
-    emptyTally = () => ({ items: {}, domains: {}, agents: {}, tiers: {} });
+    emptyTally = () => ({ items: {}, domains: {}, agents: {}, tiers: {}, sources: {} });
     MONTH_FILE_RE = /^(\d{4}-\d{2})\.(.+)\.jsonl$/;
     statsFileName = (month, machine) => `${month}.${machine}.stats.json`;
     ratio = (n, d) => d ? Math.round(n / d * 1e3) / 1e3 : null;
-    scoresFile = (kbRoot) => path30.join(kbRoot, "scores.json");
+    COMPLIANCE_MIN_EVALUATED = 3;
+    scoresFile = (kbRoot) => path31.join(kbRoot, "scores.json");
   }
 });
 
 // packages/core/dist/knowledge/report.js
-import fs30 from "fs";
-import path31 from "path";
+import fs31 from "fs";
+import path32 from "path";
 function renderReport(cfg, kb, o) {
   const { rules } = loadKbRules(cfg, kb, { includeProposed: true });
   const count = (s) => rules.filter((r) => r.status === s).length;
@@ -15093,15 +15205,15 @@ function renderReport(cfg, kb, o) {
   }
   if (o.full) {
     const { usage: usage2, caps } = o.full;
-    L.push("", "## Usage (30 days)", "", `- Surfaced: ${Object.values(usage2.surfaced).reduce((a, b) => a + b, 0)} times across ${Object.keys(usage2.surfaced).length} rules.`, `- Never surfaced (re-check triggers): ${usage2.neverSurfaced.join(", ") || "none"}`, `- Noisy (narrow triggers): ${usage2.noisy.join(", ") || "none"}`, `- Violation feedback (reword): ${usage2.violated.join(", ") || "none"}`, `- Domains over cap: ${caps.map((c) => `${c.domain} (${c.count}/${c.cap})`).join(", ") || "none"}`);
+    L.push("", "## Usage (30 days)", "", `- Surfaced: ${Object.values(usage2.surfaced).reduce((a, b) => a + b, 0)} times across ${Object.keys(usage2.surfaced).length} rules.`, `- Never surfaced (re-check triggers): ${usage2.neverSurfaced.join(", ") || "none"}`, `- Noisy (narrow triggers): ${usage2.noisy.join(", ") || "none"}`, `- Violated in graded feedback (reword): ${usage2.violated.join(", ") || "none"}`, `- Domains over cap: ${caps.map((c) => `${c.domain} (${c.count}/${c.cap})`).join(", ") || "none"}`);
   }
   if (o.scores)
     L.push(...renderScoresSection(o.scores));
   return L.join("\n") + "\n";
 }
 function writeReport(cfg, kb, o) {
-  const file = path31.join(kbDir(cfg, kb), "REPORT.md");
-  fs30.writeFileSync(file, renderReport(cfg, kb, o));
+  const file = path32.join(kbDir(cfg, kb), "REPORT.md");
+  fs31.writeFileSync(file, renderReport(cfg, kb, o));
   return file;
 }
 var init_report = __esm({
@@ -15261,6 +15373,7 @@ __export(dist_exports, {
   CITE_LOOKBACK_DAYS: () => CITE_LOOKBACK_DAYS,
   CITE_NOTE: () => CITE_NOTE,
   CMUX_PRESERVE_CLAUDE_AUTH_ENV: () => CMUX_PRESERVE_CLAUDE_AUTH_ENV,
+  COMPLIANCE_MIN_EVALUATED: () => COMPLIANCE_MIN_EVALUATED,
   CONFLICT_409_SELF_HEAL_MS: () => CONFLICT_409_SELF_HEAL_MS,
   CONVERTED_DIR: () => CONVERTED_DIR,
   CREW_GONE_MS: () => CREW_GONE_MS,
@@ -15274,6 +15387,7 @@ __export(dist_exports, {
   DEFAULT_MAX_SECTIONS_PER_PASS: () => DEFAULT_MAX_SECTIONS_PER_PASS,
   DEFAULT_SEARCH_STATUSES: () => DEFAULT_SEARCH_STATUSES,
   DEFAULT_TASK_TIMEOUT_MS: () => DEFAULT_TASK_TIMEOUT_MS,
+  DELIVERY_EVENTS: () => DELIVERY_EVENTS,
   DOCLING_DROP_THRESHOLD: () => DOCLING_DROP_THRESHOLD,
   DeferDelivery: () => DeferDelivery,
   FIRST_TURN_INLINE_MAX_BYTES: () => FIRST_TURN_INLINE_MAX_BYTES,
@@ -15293,6 +15407,7 @@ __export(dist_exports, {
   NOISY_MIN_SURFACED: () => NOISY_MIN_SURFACED,
   NOISY_RATE: () => NOISY_RATE,
   OPERATOR_INITIATED_COMMANDS: () => OPERATOR_INITIATED_COMMANDS,
+  OUTCOME_SOURCES: () => OUTCOME_SOURCES,
   PANE_IDLE_AFTER_MS: () => PANE_IDLE_AFTER_MS,
   PASS_THROUGH: () => PASS_THROUGH,
   PROBE_QUIET_MS: () => PROBE_QUIET_MS,
@@ -15301,6 +15416,7 @@ __export(dist_exports, {
   PROMPT_SINGLE_TERM_MIN_SCORE: () => PROMPT_SINGLE_TERM_MIN_SCORE,
   PROPOSED_DIR: () => PROPOSED_DIR,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  RATED_SOURCES: () => RATED_SOURCES,
   READ_ONLY_CREW_SUBCOMMANDS: () => READ_ONLY_CREW_SUBCOMMANDS,
   READ_ONLY_TOP_LEVEL_COMMANDS: () => READ_ONLY_TOP_LEVEL_COMMANDS,
   ROUTER_READY_ATTEMPTS: () => ROUTER_READY_ATTEMPTS,
@@ -15510,6 +15626,7 @@ __export(dist_exports, {
   loadSessions: () => loadSessions,
   loadSources: () => loadSources,
   loadState: () => loadState,
+  loadedDaemonLogPath: () => loadedDaemonLogPath,
   mailboxStats: () => mailboxStats,
   makeGate: () => makeGate,
   markPendingWarned: () => markPendingWarned,
@@ -15538,9 +15655,11 @@ __export(dist_exports, {
   notePaneScreen: () => notePaneScreen,
   notifyToggle: () => notifyToggle,
   orphanedErrata: () => orphanedErrata,
+  outcomeSource: () => outcomeSource,
   parseBearer: () => parseBearer,
   parseClassifierVerdict: () => parseClassifierVerdict,
   parseCommand: () => parseCommand,
+  parseLaunchctlStderrPath: () => parseLaunchctlStderrPath,
   parseLiveOpencodeServers: () => parseLiveOpencodeServers,
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
@@ -15799,23 +15918,22 @@ init_dist2();
 init_dist2();
 init_dist2();
 init_dist2();
-import { join as join27, dirname as dirname6, resolve as resolve3 } from "path";
-import { homedir as homedir14 } from "os";
+import { join as join27, dirname as dirname6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { readFileSync as readFileSync19, statSync as statSync4, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync19, statSync as statSync4, existsSync as existsSync14 } from "fs";
 
 // packages/agents/dist/drivers/claude.js
 import { execSync as execSync2 } from "child_process";
 
 // packages/agents/dist/sessions/claude-sessions.js
-import { readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
 import { join as join18 } from "path";
 
 // packages/agents/dist/claude/registry.js
-import fs31 from "fs";
+import fs32 from "fs";
 import { join as join17 } from "path";
-import { homedir as homedir7 } from "os";
-var CLAUDE_SESSIONS_DIR = join17(homedir7(), ".claude", "sessions");
+import { homedir as homedir6 } from "os";
+var CLAUDE_SESSIONS_DIR = join17(homedir6(), ".claude", "sessions");
 var PID_JSON = /^(\d+)\.json$/;
 function parseRegistryDir(files, readFile7) {
   const out = [];
@@ -15857,11 +15975,11 @@ function toLifecycleSnapshot(entry, taskId, alive, now) {
 function readClaudeStatusBySocketPath(socketPath) {
   let files;
   try {
-    files = fs31.readdirSync(CLAUDE_SESSIONS_DIR);
+    files = fs32.readdirSync(CLAUDE_SESSIONS_DIR);
   } catch {
     return void 0;
   }
-  const entries = parseRegistryDir(files, (name) => fs31.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
+  const entries = parseRegistryDir(files, (name) => fs32.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
   const entry = entries.find((e) => e.messagingSocketPath === socketPath);
   if (!entry)
     return void 0;
@@ -15878,44 +15996,43 @@ import { execSync as execSync4 } from "child_process";
 import { execSync as execSync5 } from "child_process";
 
 // packages/agents/dist/sessions/opencode-sessions.js
-import { readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
+init_dist();
+import { readdirSync as readdirSync6, readFileSync as readFileSync13 } from "fs";
 import { join as join19 } from "path";
-import { homedir as homedir8 } from "os";
-var SQUADRANT_STATE_DIR = join19(homedir8(), ".config", "squadrant", "state");
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs32 from "fs";
-import path32 from "path";
+import fs33 from "fs";
+import path33 from "path";
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path33 from "path";
-import os9 from "os";
+import path34 from "path";
+import os10 from "os";
 
 // packages/agents/dist/projection/codex.js
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path34 from "path";
-import os10 from "os";
+import path35 from "path";
+import os11 from "os";
 
 // packages/agents/dist/projection/gemini.js
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path35 from "path";
-import os11 from "os";
+import path36 from "path";
+import os12 from "os";
 
 // packages/agents/dist/projection/opencode.js
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import path36 from "path";
-import os12 from "os";
+import path37 from "path";
+import os13 from "os";
 
 // packages/agents/dist/projection/opencode-skills.js
-import fs33 from "fs";
-import os13 from "os";
-import path37 from "path";
+import fs34 from "fs";
+import os14 from "os";
+import path38 from "path";
 var OPENCODE_SKILL_MARKER = ".squadrant-managed";
 var MARKER_BODY = "squadrant\n";
 function defaultOpencodeSkillsRoot(env = process.env) {
-  const configHome = env.XDG_CONFIG_HOME || path37.join(os13.homedir(), ".config");
-  return path37.join(configHome, "opencode", "skills");
+  const configHome = env.XDG_CONFIG_HOME || path38.join(os14.homedir(), ".config");
+  return path38.join(configHome, "opencode", "skills");
 }
 var SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function parseSkillName(raw) {
@@ -15930,62 +16047,62 @@ function parseSkillName(raw) {
 }
 function listSourceSkills(sourceSkillsDir) {
   const out = /* @__PURE__ */ new Map();
-  if (!fs33.existsSync(sourceSkillsDir))
+  if (!fs34.existsSync(sourceSkillsDir))
     return out;
-  for (const entry of fs33.readdirSync(sourceSkillsDir, { withFileTypes: true })) {
+  for (const entry of fs34.readdirSync(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
-    const skillPath = path37.join(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!fs33.existsSync(skillPath))
+    const skillPath = path38.join(sourceSkillsDir, entry.name, "SKILL.md");
+    if (!fs34.existsSync(skillPath))
       continue;
-    const name = parseSkillName(fs33.readFileSync(skillPath, "utf-8"));
+    const name = parseSkillName(fs34.readFileSync(skillPath, "utf-8"));
     if (name && SAFE_NAME.test(name))
       out.set(name, skillPath);
   }
   return out;
 }
 function hasMarker(dir) {
-  return fs33.existsSync(path37.join(dir, OPENCODE_SKILL_MARKER));
+  return fs34.existsSync(path38.join(dir, OPENCODE_SKILL_MARKER));
 }
 function syncOpencodeSkills(opts) {
   const result = { written: [], unchanged: [], removed: [], skipped: [] };
   const wanted = listSourceSkills(opts.sourceSkillsDir);
-  if (wanted.size === 0 && !fs33.existsSync(opts.sourceSkillsDir))
+  if (wanted.size === 0 && !fs34.existsSync(opts.sourceSkillsDir))
     return result;
   if (!opts.dryRun)
-    fs33.mkdirSync(opts.skillsRoot, { recursive: true });
+    fs34.mkdirSync(opts.skillsRoot, { recursive: true });
   for (const [name, srcPath] of wanted) {
-    const targetDir = path37.join(opts.skillsRoot, name);
-    const targetSkill = path37.join(targetDir, "SKILL.md");
+    const targetDir = path38.join(opts.skillsRoot, name);
+    const targetSkill = path38.join(targetDir, "SKILL.md");
     const managed = hasMarker(targetDir);
-    if (fs33.existsSync(targetSkill) && !managed) {
+    if (fs34.existsSync(targetSkill) && !managed) {
       result.skipped.push({ name, reason: "foreign-collision" });
       continue;
     }
-    const current = fs33.existsSync(targetSkill) ? fs33.readFileSync(targetSkill) : null;
-    if (current && current.equals(fs33.readFileSync(srcPath))) {
+    const current = fs34.existsSync(targetSkill) ? fs34.readFileSync(targetSkill) : null;
+    if (current && current.equals(fs34.readFileSync(srcPath))) {
       if (!managed && !opts.dryRun) {
-        fs33.writeFileSync(path37.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
+        fs34.writeFileSync(path38.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
       }
       result.unchanged.push(name);
       continue;
     }
     if (!opts.dryRun) {
-      fs33.mkdirSync(targetDir, { recursive: true });
-      fs33.copyFileSync(srcPath, targetSkill);
-      fs33.writeFileSync(path37.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
+      fs34.mkdirSync(targetDir, { recursive: true });
+      fs34.copyFileSync(srcPath, targetSkill);
+      fs34.writeFileSync(path38.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
     }
     result.written.push(name);
   }
-  if (fs33.existsSync(opts.skillsRoot)) {
-    for (const entry of fs33.readdirSync(opts.skillsRoot, { withFileTypes: true })) {
+  if (fs34.existsSync(opts.skillsRoot)) {
+    for (const entry of fs34.readdirSync(opts.skillsRoot, { withFileTypes: true })) {
       if (!entry.isDirectory() || wanted.has(entry.name))
         continue;
-      const dir = path37.join(opts.skillsRoot, entry.name);
+      const dir = path38.join(opts.skillsRoot, entry.name);
       if (!hasMarker(dir))
         continue;
       if (!opts.dryRun)
-        fs33.rmSync(dir, { recursive: true, force: true });
+        fs34.rmSync(dir, { recursive: true, force: true });
       result.removed.push(entry.name);
     }
   }
@@ -15993,7 +16110,7 @@ function syncOpencodeSkills(opts) {
 }
 function syncShippedOpencodeSkills(opts) {
   return syncOpencodeSkills({
-    sourceSkillsDir: path37.join(opts.pkgRoot, "plugin", "skills"),
+    sourceSkillsDir: path38.join(opts.pkgRoot, "plugin", "skills"),
     skillsRoot: opts.skillsRoot ?? defaultOpencodeSkillsRoot(),
     dryRun: opts.dryRun
   });
@@ -16001,8 +16118,8 @@ function syncShippedOpencodeSkills(opts) {
 
 // packages/agents/dist/projection/claude.js
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path38 from "path";
-import os14 from "os";
+import path39 from "path";
+import os15 from "os";
 
 // packages/agents/dist/codex/app-server-client.js
 import { EventEmitter } from "events";
@@ -16056,8 +16173,8 @@ var AppServerClient = class extends EventEmitter {
     const info = this.opts.clientInfo ?? { name: "squadrant", version: "0" };
     const id = this.nextId++;
     const env = { jsonrpc: "2.0", id, method: "initialize", params: { clientInfo: info } };
-    const res = await new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+    const res = await new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
       this.proc.stdin.write(JSON.stringify(env) + "\n");
     });
     this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "initialized" }) + "\n");
@@ -16090,13 +16207,13 @@ var AppServerClient = class extends EventEmitter {
     const turnId = ack?.turn?.id;
     if (typeof turnId !== "string")
       throw new Error(`turn/start: unexpected ack shape (no turn.id): ${JSON.stringify(ack).slice(0, 200)}`);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const onNote = (n) => {
         if (n.params?.turn?.id !== turnId)
           return;
         if (n.method === "turn/completed") {
           cleanup();
-          resolve4({ turnId });
+          resolve5({ turnId });
         }
         if (n.method === "turn/failed") {
           cleanup();
@@ -16147,8 +16264,8 @@ var AppServerClient = class extends EventEmitter {
       throw new Error("AppServerClient not started");
     const id = this.nextId++;
     const env = { jsonrpc: "2.0", id, method, params: params ?? {} };
-    return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
       this.proc.stdin.write(JSON.stringify(env) + "\n");
     });
   }
@@ -16276,10 +16393,10 @@ function toSnapshot(ev2) {
 
 // packages/agents/dist/codex/config.js
 import { readFile as readFile6 } from "fs/promises";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join20 } from "path";
 async function resolveCodexModel() {
-  const home = process.env["CODEX_HOME"] ?? join20(homedir9(), ".codex");
+  const home = process.env["CODEX_HOME"] ?? join20(homedir7(), ".codex");
   const configPath = join20(home, "config.toml");
   let text;
   try {
@@ -16594,11 +16711,11 @@ function buildCodexDeveloperInstructions(rec) {
 ${directive}` : directive;
 }
 function withTimeout(p, ms, msg) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const t = setTimeout(() => reject(new Error(msg)), ms);
     p.then((v2) => {
       clearTimeout(t);
-      resolve4(v2);
+      resolve5(v2);
     }, (e) => {
       clearTimeout(t);
       reject(e);
@@ -16839,7 +16956,7 @@ var OpencodeSseBridge = class {
 // packages/agents/dist/interactive/claude.js
 import { execSync as execSync6 } from "child_process";
 import { readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir10 } from "os";
+import { homedir as homedir8 } from "os";
 import { join as join21 } from "path";
 var nextHookRequestId = Date.now();
 
@@ -16973,14 +17090,14 @@ function runHeadless(opts) {
     if (err.length > ERR_CAP)
       err = err.slice(err.length - ERR_CAP);
   });
-  const result = new Promise((resolve4) => {
+  const result = new Promise((resolve5) => {
     child.once("error", (e) => {
       if (debounceTimer) {
         clearTimeout(debounceTimer);
         debounceTimer = null;
       }
       opts.emit({ type: "task.failed", id: opts.id, error: `spawn error: ${e.message}`, exitCode: void 0 });
-      resolve4();
+      resolve5();
     });
     child.on("close", (code) => {
       if (chunksSinceProgress > 0)
@@ -16997,14 +17114,14 @@ function runHeadless(opts) {
         const ref = opts.writeResult ? opts.writeResult(opts.id, res.payload ?? "") : "";
         opts.emit({ type: "task.done", id: opts.id, resultRef: ref, parseWarning: res.parseWarning });
       }
-      resolve4();
+      resolve5();
     });
   });
   return { result, kill: () => child.kill("SIGTERM") };
 }
 
 // packages/agents/dist/claude/peer-registry-source.js
-import { readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
 import { join as join22 } from "path";
 function defaultIsAlive(pid) {
   try {
@@ -17029,7 +17146,7 @@ var ClaudePeerRegistrySource = class {
   pollMs;
   log;
   constructor(o = {}) {
-    this.readdir = o.readdir ?? (() => readdirSync6(CLAUDE_SESSIONS_DIR));
+    this.readdir = o.readdir ?? (() => readdirSync7(CLAUDE_SESSIONS_DIR));
     this.readFile = o.readFile ?? ((n) => readFileSync15(join22(CLAUDE_SESSIONS_DIR, n), "utf8"));
     this.isAlive = o.isAlive ?? defaultIsAlive;
     this.now = o.now ?? Date.now;
@@ -17128,12 +17245,12 @@ function writeLine(socketPath, envelope, deps) {
       error: `line exceeds the receiver's 1 MiB buffer cap (${Buffer.byteLength(line2, "utf8")} bytes)`
     });
   }
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     const done = (r) => {
       if (!settled) {
         settled = true;
-        resolve4(r);
+        resolve5(r);
       }
     };
     const sock = deps.connect(socketPath);
@@ -17255,13 +17372,13 @@ var ClaudeReceiptListener = class {
    * target is a live socket and the subsequent listen fails loudly instead.
    */
   start() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       this.deps.unlinkStale?.(this.deps.socketPath);
       this.server = this.deps.createServer((conn) => this.handle(conn));
       this.server.once("error", (e) => reject(e));
       this.server.listen(this.deps.socketPath, () => {
         this.server.unref?.();
-        resolve4();
+        resolve5();
       });
     });
   }
@@ -17287,15 +17404,15 @@ var ClaudeReceiptListener = class {
    * is silent by design, so "no receipt" is the common, healthy case.
    */
   waitFor(origMsgId, timeoutMs) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const timer = setTimeout(() => {
         this.waiters.delete(origMsgId);
-        resolve4(void 0);
+        resolve5(void 0);
       }, timeoutMs);
       this.waiters.set(origMsgId, (r) => {
         clearTimeout(timer);
         this.waiters.delete(origMsgId);
-        resolve4(r);
+        resolve5(r);
       });
     });
   }
@@ -17346,9 +17463,9 @@ var ClaudeReceiptListener = class {
 };
 
 // packages/agents/dist/claude/api-key-approval.js
-import fs34 from "fs";
-import os15 from "os";
-import path39 from "path";
+import fs35 from "fs";
+import os16 from "os";
+import path40 from "path";
 
 // packages/agents/dist/opencode/http-channel.js
 init_dist2();
@@ -17440,10 +17557,10 @@ var OpencodeHttpChannel = class {
       return cached;
     const directory = this.directoryFor?.(taskId);
     const createdAfterMs = this.createdAfterFor?.(taskId);
-    for (const path43 of ["/session?", "/api/session?"]) {
+    for (const path44 of ["/session?", "/api/session?"]) {
       let res;
       try {
-        res = await this.request(`http://127.0.0.1:${port}${path43}`, { method: "GET" });
+        res = await this.request(`http://127.0.0.1:${port}${path44}`, { method: "GET" });
       } catch {
         return void 0;
       }
@@ -17517,9 +17634,9 @@ function createOpencodeFactAdapter(deps) {
 }
 
 // packages/agents/dist/rules-hooks/install.js
-import fs35 from "fs";
-import os16 from "os";
-import path40 from "path";
+import fs36 from "fs";
+import os17 from "os";
+import path41 from "path";
 
 // packages/workspaces/dist/runtimes/cmux.js
 init_dist();
@@ -17536,7 +17653,7 @@ var CmuxTimeoutError = class extends Error {
   }
 };
 function cmux(args) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     execFile3(
       resolveCmuxBin(),
       args,
@@ -17550,19 +17667,19 @@ function cmux(args) {
           reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
           return;
         }
-        resolve4(stdout.trim());
+        resolve5(stdout.trim());
       }
     );
   });
 }
 function cmuxStdin(args, input) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = execFile3(resolveCmuxBin(), args, { encoding: "utf-8", timeout: CMUX_TIMEOUT, env: { ...process.env, CMUX_QUIET: "1" } }, (err, stdout) => {
       if (err) {
         reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
         return;
       }
-      resolve4(stdout.trim());
+      resolve5(stdout.trim());
     });
     child.stdin.end(input);
   });
@@ -18257,9 +18374,9 @@ var NotifierRegistry = class {
 };
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs36 from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path41 from "path";
+import fs37 from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path42 from "path";
 
 // packages/workspaces/dist/workspaces/registry.js
 init_dist();
@@ -18331,12 +18448,12 @@ var CmuxEventsBridge = class {
         continue;
       }
       this.child = child;
-      await new Promise((resolve4) => {
+      await new Promise((resolve5) => {
         let settled = false;
         const done = () => {
           if (!settled) {
             settled = true;
-            resolve4();
+            resolve5();
           }
         };
         child.stdout?.on("data", (b) => this.onData(b));
@@ -18412,9 +18529,9 @@ var CmuxEventsBridge = class {
 // packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 init_dist2();
 init_dist();
-import { readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync16 } from "fs";
 import { join as join23 } from "path";
-import { homedir as homedir11 } from "os";
+import { homedir as homedir9 } from "os";
 
 // packages/workspaces/dist/cmux-daemon/store-fingerprint.js
 init_dist();
@@ -18511,11 +18628,11 @@ function readLivenessSnapshot(files, readFile7, projects, argvRecovery = {}) {
 
 // packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 async function readCmuxLiveness() {
-  const dir = process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join23(homedir11(), ".cmuxterm");
+  const dir = process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join23(homedir9(), ".cmuxterm");
   const projects = loadConfig().projects;
   let files;
   try {
-    files = readdirSync7(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    files = readdirSync8(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
   } catch (e) {
     throw new Error(`liveness: could not read cmux state dir ${dir}: ${e.message}`);
   }
@@ -18583,8 +18700,8 @@ var DaemonCmux = class {
 
 // packages/workspaces/dist/cmux-daemon/cmux-store-source.js
 import { join as join24 } from "path";
-import { homedir as homedir12 } from "os";
-import { watch, readdirSync as readdirSync8, readFileSync as readFileSync17, existsSync as existsSync12 } from "fs";
+import { homedir as homedir10 } from "os";
+import { watch, readdirSync as readdirSync9, readFileSync as readFileSync17, existsSync as existsSync13 } from "fs";
 var CmuxStoreSource = class {
   name = "cmux-store";
   stateDir;
@@ -18613,7 +18730,7 @@ var CmuxStoreSource = class {
   active = false;
   lastError = null;
   constructor(opts = {}) {
-    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join24(homedir12(), ".cmuxterm");
+    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join24(homedir10(), ".cmuxterm");
     this.debounceMs = opts.debounceMs ?? 50;
     this.lockRetryMs = opts.lockRetryMs ?? 50;
     this.maxLockRetries = opts.maxLockRetries ?? 3;
@@ -18621,7 +18738,7 @@ var CmuxStoreSource = class {
     this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive2;
     this.listFiles = opts.listFiles ?? defaultListFiles;
     this.readFile = opts.readFile ?? defaultReadFile;
-    this.fileExists = opts.fileExists ?? existsSync12;
+    this.fileExists = opts.fileExists ?? existsSync13;
     this.watchDir = opts.watchDir ?? defaultWatchDir;
     this.scheduleTimer = opts.scheduleTimer ?? setTimeout;
     this.cancelTimer = opts.cancelTimer ?? clearTimeout;
@@ -18804,14 +18921,14 @@ function defaultIsPidAlive2(pid) {
 }
 function defaultListFiles(dir) {
   try {
-    return readdirSync8(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    return readdirSync9(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
   } catch {
     return [];
   }
 }
-function defaultReadFile(path43) {
+function defaultReadFile(path44) {
   try {
-    return readFileSync17(path43, "utf-8");
+    return readFileSync17(path44, "utf-8");
   } catch {
     return void 0;
   }
@@ -18828,8 +18945,8 @@ function defaultWatchDir(dir, cb, onError) {
 
 // packages/workspaces/dist/native-hooks/native-hook-source.js
 import { join as join25 } from "path";
-import { homedir as homedir13 } from "os";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir11 } from "os";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
 var CLAUDE_HOOK_EVENTS = [
   ["SessionStart", "session-start"],
   ["UserPromptSubmit", "prompt-submit"],
@@ -18936,7 +19053,7 @@ function removeForeignGateHandlers(entries) {
   return removed;
 }
 function installClaudeHooks(opts = {}) {
-  const settingsPath = opts.settingsPath ?? join25(homedir13(), ".claude", "settings.json");
+  const settingsPath = opts.settingsPath ?? join25(homedir11(), ".claude", "settings.json");
   const cliCmd = opts.cliCmd ?? DEFAULT_CLI_CMD;
   const hookCmd = opts.hookCmd ?? `${cliCmd} hooks`;
   const gateCmd = `${cliCmd} gate`;
@@ -19191,16 +19308,16 @@ function extractDetail(sub, payload) {
   }
   return void 0;
 }
-function defaultReadFile2(path43) {
+function defaultReadFile2(path44) {
   try {
-    return readFileSync18(path43, "utf-8");
+    return readFileSync18(path44, "utf-8");
   } catch {
     return void 0;
   }
 }
-function defaultWriteFile(path43, content) {
-  mkdirSync8(path43.replace(/\/[^/]+$/, ""), { recursive: true });
-  writeFileSync11(path43, content, "utf-8");
+function defaultWriteFile(path44, content) {
+  mkdirSync9(path44.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync12(path44, content, "utf-8");
 }
 
 // packages/workspaces/dist/crew-pane.js
@@ -19285,24 +19402,24 @@ init_dist();
 
 // packages/cli/src/lib/daemon-restart-broadcast.ts
 init_dist();
-import path42 from "path";
-function statePath2(stateRoot) {
-  return path42.join(stateRoot, "daemon-restart-state.json");
+import path43 from "path";
+function statePath2(stateRoot2) {
+  return path43.join(stateRoot2, "daemon-restart-state.json");
 }
 function computeRestartSignature(version, buildMtimeMs) {
   return `${version}::${buildMtimeMs}`;
 }
-function readPersistedRestartSignature(stateRoot) {
+function readPersistedRestartSignature(stateRoot2) {
   try {
-    const raw = readConfigFileSync(statePath2(stateRoot));
+    const raw = readConfigFileSync(statePath2(stateRoot2));
     const data = JSON.parse(raw);
     return typeof data.signature === "string" ? data.signature : null;
   } catch {
     return null;
   }
 }
-function writePersistedRestartSignature(stateRoot, signature) {
-  writeConfigFileSync(statePath2(stateRoot), JSON.stringify({ signature }, null, 2) + "\n");
+function writePersistedRestartSignature(stateRoot2, signature) {
+  writeConfigFileSync(statePath2(stateRoot2), JSON.stringify({ signature }, null, 2) + "\n");
 }
 function restartNotice(version, isDevRebuild) {
   const suffix = isDevRebuild ? " (dev build)" : "";
@@ -19323,20 +19440,20 @@ async function notifyCaptainsOfDaemonRestart(version, config, driver, isDevRebui
 }
 async function maybeBroadcastDaemonRestart(opts) {
   try {
-    const { version, buildMtimeMs, stateRoot, config, driver, appendCaptainMessage: appendCaptainMessage2 } = opts;
+    const { version, buildMtimeMs, stateRoot: stateRoot2, config, driver, appendCaptainMessage: appendCaptainMessage2 } = opts;
     const signature = computeRestartSignature(version, buildMtimeMs);
-    const previous = readPersistedRestartSignature(stateRoot);
+    const previous = readPersistedRestartSignature(stateRoot2);
     if (previous === signature) return;
     const isDevRebuild = previous !== null && previous.split("::")[0] === version;
     await notifyCaptainsOfDaemonRestart(version, config, driver, isDevRebuild, appendCaptainMessage2);
-    writePersistedRestartSignature(stateRoot, signature);
+    writePersistedRestartSignature(stateRoot2, signature);
   } catch {
   }
 }
 
 // packages/cli/src/lib/captain-channel-factory.ts
 import { createServer as createServer4, connect as netConnect } from "net";
-import fs37 from "fs";
+import fs38 from "fs";
 import { join as join26 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import chalk2 from "chalk";
@@ -19345,15 +19462,15 @@ var shared;
 var registryEntryPath = () => join26(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
 function unregisterSenderIdentity() {
   try {
-    fs37.unlinkSync(registryEntryPath());
+    fs38.unlinkSync(registryEntryPath());
   } catch {
   }
 }
 function registerSenderIdentity(socketPath) {
   try {
     unregisterSenderIdentity();
-    fs37.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
-    fs37.writeFileSync(
+    fs38.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
+    fs38.writeFileSync(
       registryEntryPath(),
       JSON.stringify({
         pid: process.pid,
@@ -19379,7 +19496,7 @@ async function sharedReceiptListener() {
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs37.unlinkSync(p);
+        fs38.unlinkSync(p);
       } catch {
       }
     },
@@ -19404,7 +19521,7 @@ async function buildCaptainChannel() {
     // in /tmp/x registers cwd "/private/tmp/x" on macOS, so cwd matching silently
     // missed and every captain ping reported accepted-unconfirmed.
     statusFor: (taskId) => readClaudeStatusBySocketPath(captainSocketPath(taskId)),
-    wire: (p, e) => writeLine(p, e, { connect: (path43) => netConnect(path43) }),
+    wire: (p, e) => writeLine(p, e, { connect: (path44) => netConnect(path44) }),
     receipts,
     newMsgId: () => randomUUID5(),
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -19422,8 +19539,8 @@ async function buildCaptainChannels(opts) {
     agentFor: (project) => resolveCaptainAgent(opts.stateRoot, project, opts.configAgent)
   };
 }
-function resolveCaptainAgent(stateRoot, project, configAgent) {
-  return readCaptainAddress(stateRoot, project)?.agent ?? configAgent;
+function resolveCaptainAgent(stateRoot2, project, configAgent) {
+  return readCaptainAddress(stateRoot2, project)?.agent ?? configAgent;
 }
 async function retryForever(build, opts = {}) {
   const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => {
@@ -19463,7 +19580,7 @@ function readPkgVersion() {
   }
 }
 var PKG_VERSION = readPkgVersion();
-function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
+function buildTelegramBridge(cfg, stateRoot2, log, deliverInbound, usageFor) {
   const token = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
   if (!token) {
     log("telegram: config present but no botToken / TELEGRAM_BOT_TOKEN set \u2014 bridge disabled");
@@ -19477,7 +19594,7 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
   const runCommand = createRunCommand(CLI_BIN);
   const sendReply = (threadId, text, replyMarkup) => client.sendMessage(cfg.supergroupId, threadId, text, replyMarkup);
   const lifecycle = createInboundLifecycle({
-    stateRoot,
+    stateRoot: stateRoot2,
     cfg: { supergroupId: cfg.supergroupId },
     sendChatAction: (chatId, threadId, action) => client.sendChatAction(chatId, threadId, action),
     sendReply: async (threadId, text) => {
@@ -19498,15 +19615,15 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
         // timestamp, so the reader hashes the screen and asks the persisted
         // pending store how long that exact screen has been up. Persisted, so a
         // daemon restart cannot hand a dead captain a fresh 15 minutes.
-        noteScreen: (project, hash) => notePaneScreen(stateRoot, project, hash, Date.now())
+        noteScreen: (project, hash) => notePaneScreen(stateRoot2, project, hash, Date.now())
       }
     ),
     log
   });
   return createTelegramBridge({
     cfg,
-    stateRoot,
-    configRoot: dirname6(stateRoot),
+    stateRoot: stateRoot2,
+    configRoot: CONFIG_DIR,
     client,
     appendCaptainMessage,
     log,
@@ -19522,7 +19639,7 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
     // every link on the machine. `undefined` correctly means "don't prune".
     registeredProjects: () => {
       try {
-        const parsed = JSON.parse(readFileSync19(join27(dirname6(stateRoot), "config.json"), "utf8"));
+        const parsed = JSON.parse(readFileSync19(DEFAULT_CONFIG_PATH, "utf8"));
         return Object.keys(parsed.projects ?? {});
       } catch {
         return void 0;
@@ -19562,8 +19679,18 @@ function startSquadrantd(opts = {}) {
 `
     );
   }
+  if (isDefaultSocket && !opts.stateRoot) {
+    try {
+      const seed = seedStateFromLegacy();
+      if (seed.seeded) process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} state seeded from legacy ${legacyStateDir()} \u2192 ${stateRoot()}
+`);
+    } catch (err) {
+      process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} legacy state seed failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
   const ctx = buildContext(opts);
-  const { stateRoot, store, log, spawn: spawn2, writeResult, inFlightHeadlessIds, activeHeadlessKills } = ctx;
+  const { stateRoot: stateRoot2, store, log, spawn: spawn2, writeResult, inFlightHeadlessIds, activeHeadlessKills } = ctx;
   const { broadcast, schedulePromotion, cancelPromotionsFor } = createAttach(ctx);
   ctx.broadcast = broadcast;
   ctx.schedulePromotion = schedulePromotion;
@@ -19639,7 +19766,7 @@ function startSquadrantd(opts = {}) {
       const rec = store.listAll().find((r) => r.id === taskId);
       if (!rec) return false;
       try {
-        const cfg2 = JSON.parse(readFileSync19(join27(stateRoot, rec.project, taskId, "opencode.json"), "utf8"));
+        const cfg2 = JSON.parse(readFileSync19(join27(stateRoot2, rec.project, taskId, "opencode.json"), "utf8"));
         return cfg2?.permission?.bash === "ask" && cfg2?.permission?.edit === "ask";
       } catch {
         return false;
@@ -19659,7 +19786,7 @@ function startSquadrantd(opts = {}) {
         (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && r.cwd === hook.cwd
       );
     },
-    cursorFile: join27(stateRoot, "cmux-events.seq"),
+    cursorFile: join27(stateRoot2, "cmux-events.seq"),
     log
   });
   const cmuxStoreSource = new CmuxStoreSource({ log });
@@ -19689,7 +19816,7 @@ function startSquadrantd(opts = {}) {
   const tgCfg = loadConfig().telegram;
   ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(
     tgCfg,
-    stateRoot,
+    stateRoot2,
     log,
     (project, text) => Promise.resolve().then(() => (init_dist2(), dist_exports)).then((core2) => core2.deliverToCaptain(project, text, {
       channel: ctx.captainChannel,
@@ -19708,7 +19835,7 @@ function startSquadrantd(opts = {}) {
     ctx.captainChannelMode = () => resolveCaptainChannelMode(loadConfig().defaults);
     if (ctx.captainChannelMode() !== "off") {
       void buildCaptainChannelsWithRetry({
-        stateRoot: join27(homedir14(), ".config", "squadrant", "state"),
+        stateRoot: ctx.stateRoot,
         configAgent: loadConfig().defaults.roles?.captain?.agent,
         log
       }).then(({ channels, agentFor }) => {
@@ -19923,10 +20050,10 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
       void maybeBroadcastDaemonRestart({
         version: PKG_VERSION,
         buildMtimeMs,
-        stateRoot,
+        stateRoot: stateRoot2,
         config: restartConfig,
         driver: registry.global(restartConfig),
-        appendCaptainMessage: (project, text) => appendCaptainMessage({ stateRoot, project, text, source: "daemon" })
+        appendCaptainMessage: (project, text) => appendCaptainMessage({ stateRoot: stateRoot2, project, text, source: "daemon" })
       });
     } catch (e) {
       log(`daemon-restart broadcast setup failed: ${e.message}`);
@@ -19962,8 +20089,8 @@ function logCrashMarker(kind, err) {
   const message = err instanceof Error ? err.stack ?? err.message : String(err);
   process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${kind} pid=${process.pid} error=${message}
 `);
-  const stateRoot = join27(homedir14(), ".config", "squadrant", "state");
-  writeExitMarker(stateRoot, {
+  const stateRoot2 = stateRoot();
+  writeExitMarker(stateRoot2, {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     pid: process.pid,
     reason: kind,
@@ -19974,8 +20101,8 @@ function logCrashMarker(kind, err) {
   }, (m) => process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${m}
 `));
 }
-function isMonorepoCheckout(scriptPath, dirExists = existsSync13) {
-  return dirExists(join27(dirname6(resolve3(scriptPath)), "..", "packages"));
+function isMonorepoCheckout(scriptPath, dirExists = existsSync14) {
+  return dirExists(join27(dirname6(resolve4(scriptPath)), "..", "packages"));
 }
 function isLinkedWorktree(scriptPath, statFile = (p) => {
   try {
@@ -19984,7 +20111,7 @@ function isLinkedWorktree(scriptPath, statFile = (p) => {
     return void 0;
   }
 }) {
-  const dotGit = join27(dirname6(resolve3(scriptPath)), "..", ".git");
+  const dotGit = join27(dirname6(resolve4(scriptPath)), "..", ".git");
   return statFile(dotGit)?.isFile === true;
 }
 if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
@@ -20011,13 +20138,13 @@ if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
       sweepMs: 3e4,
       // #898: KB reconcile scheduler on the 60s tick. Enqueues to the home captain's mailbox; never spawns.
       knowledgeTick: async () => {
-        const stateRoot = join27(homedir14(), ".config", "squadrant", "state");
+        const stateRoot2 = stateRoot();
         await tickKnowledgeSchedule({
           cfg: loadConfig(),
-          stateRoot,
+          stateRoot: stateRoot2,
           log: (m) => process.stderr.write(`[squadrantd] ${m}
 `),
-          enqueue: (project, text) => appendCaptainMessage({ stateRoot, project, text, source: "daemon" })
+          enqueue: (project, text) => appendCaptainMessage({ stateRoot: stateRoot2, project, text, source: "daemon" })
         });
       }
     });