@integrity-labs/agt-cli 0.28.360 → 0.28.362

package/dist/lib/manager-worker.js

@@ -2,15 +2,12 @@ import {
   ApiError,
   CHANNEL_SECRET_ENV_KEYS,
   HostFlagStore,
-  HttpOpencodeClient,
   INTEGRATIONS_SECTION_END,
   INTEGRATIONS_SECTION_START,
-  OpencodeInboundBridge,
   SUPERVISOR_RESTART_EXIT_CODE,
   api,
   atomicWriteFileSync,
   buildConnectivityProbeDeps,
-  buildOpencodeTranscript,
   buildProbeEnv,
   classifyEnvIntegrationsDiff,
   clearPresenceReaperState,
@@ -19,7 +16,6 @@ import {
   defaultFlagsCachePath,
   deriveMcpServerKey,
   diffEnvIntegrations,
-  emptyOpencodeTranscript,
   envOnlyRespawnVars,
   estimateActiveTasksTokens,
   exchangeApiKey,
@@ -32,7 +28,6 @@ import {
   getHostId,
   givenUpMcpServerKeys,
   liveProxyExtraHeaderVars,
-  parseOpencodeModelRef,
   pinAllowsUrgent,
   provision,
   provisionAutoKanbanProgressHook,
@@ -42,15 +37,13 @@ import {
   provisionPreCompactHook,
   provisionSessionStateHook,
   provisionStopHook,
-  readChannelServerEnv,
   reapMissingMcpSessions,
   reapStaleMcpChildren,
   requireHost,
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
-  setConfigHash,
-  toOpencodeModel
-} from "../chunk-U62E42YH.js";
+  setConfigHash
+} from "../chunk-B2SWCMJ7.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -83,6 +76,7 @@ import {
   creditWatchdogGiveUpCount,
   describeOnboardingChannel,
   egressMode,
+  execFilePromiseLong,
   extractFrontmatter,
   formatActorId,
   formatRunMarker,
@@ -91,14 +85,17 @@ import {
   getLastFailureContext,
   getProjectDir,
   getSessionState,
+  hashFile,
   injectMessage,
   injectMessageWithStatus,
+  injectOpencodeMessage,
   isAgentIdle,
   isAgentPromptReady,
   isBareAck,
   isConversationFailureCategory,
   isEmptyTotals,
   isOnboardingArea,
+  isOpencodeSessionHealthy,
   isParseError,
   isResolveError,
   isSelfCompletion,
@@ -109,6 +106,7 @@ import {
   isVacuousDeliverReason,
   isolationMode,
   laneTagFragment,
+  log,
   minutesSinceLocalMidnight,
   paneLogPath,
   parseDeliverAssertion,
@@ -118,8 +116,11 @@ import {
   parseUsageBanner,
   peekCurrentSession,
   prepareForRespawn,
+  readChannelServerEnv,
   readDirectChatSessionState,
+  readOpencodePaneLogTail,
   readPaneLogTail,
+  readProvisionedOpencodeModel,
   reloadEgressSidecar,
   resetRestartCount,
   resolveAgentTimezone,
@@ -132,26 +133,30 @@ import {
   sendToAgent,
   serializeUsageLimitMarker,
   sessionTranscriptDir,
+  sha256,
+  startOpencodeSession,
   startPersistentSession,
   stopAllSessionsAndWait,
+  stopOpencodeSession,
   stopPersistentSession,
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   takeWatchdogGiveUpCount,
   takeZombieDetection,
+  toOpencodeModel,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-Z7QR2YEJ.js";
+} from "../chunk-3D7IBJYZ.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash14 } from "crypto";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, existsSync as existsSync13, rmSync as rmSync6, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
+import { createHash as createHash13 } from "crypto";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, mkdirSync as mkdirSync8, existsSync as existsSync11, rmSync as rmSync5, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join23, dirname as dirname7, delimiter as pathDelimiter } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join21, dirname as dirname5, delimiter as pathDelimiter } from "path";
+import { homedir as homedir10 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/claude-code-upgrade-throttle.ts
@@ -3976,125 +3981,6 @@ function writeManagedSkillManifest(path, ids) {
   }
 }
 
-// src/lib/manager/runtime.ts
-import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync13, appendFileSync, mkdirSync as mkdirSync6, chmodSync, existsSync as existsSync6 } from "fs";
-import { join as join14, dirname as dirname5 } from "path";
-import { homedir as homedir6 } from "os";
-function redactForDiskLog(value) {
-  try {
-    return value.replace(/\b(Bearer\s+)[A-Za-z0-9._-]+\b/gi, "$1[REDACTED]").replace(/\bxox[baprs]-[A-Za-z0-9-]+\b/g, "[REDACTED-SLACK]").replace(/\btlk_[A-Za-z0-9._-]+\b/g, "[REDACTED-HOST]").replace(/\bsk-ant-[A-Za-z0-9_-]+\b/g, "[REDACTED-ANTHROPIC]").replace(/\b\d{8,12}:[A-Za-z0-9_-]{30,}\b/g, "[REDACTED-TELEGRAM]").replace(
-      /\b([A-Z0-9_]*(?:TOKEN|SECRET|API[_-]?KEY|PASSWORD)[A-Z0-9_]*)=(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s\r\n]+)/gi,
-      "$1=[REDACTED]"
-    );
-  } catch {
-    return "[REDACTED]";
-  }
-}
-var managerLogPath = null;
-var managerLogWritable = true;
-function log(msg) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const safeMsg = redactForDiskLog(msg);
-  const line = `[manager-worker ${ts}] ${safeMsg}
-`;
-  if (!managerLogPath) {
-    try {
-      managerLogPath = join14(homedir6(), ".augmented", "manager.log");
-      mkdirSync6(dirname5(managerLogPath), { recursive: true });
-      if (existsSync6(managerLogPath)) {
-        chmodSync(managerLogPath, 384);
-      }
-    } catch {
-    }
-  }
-  let appendedToFile = false;
-  if (managerLogPath && managerLogWritable) {
-    try {
-      appendFileSync(managerLogPath, line, { encoding: "utf-8", mode: 384 });
-      appendedToFile = true;
-    } catch (err) {
-      managerLogWritable = false;
-      process.stderr.write(
-        `[manager-worker ${ts}] [log] manager.log append failed; falling back to stderr-only: ${err.message}
-`
-      );
-    }
-  }
-  if (!appendedToFile || process.stderr.isTTY === true) {
-    process.stderr.write(line);
-  }
-}
-function sha256(content) {
-  return createHash6("sha256").update(content, "utf8").digest("hex");
-}
-function hashFile(filePath) {
-  try {
-    const content = readFileSync13(filePath, "utf-8");
-    return sha256(content);
-  } catch {
-    return null;
-  }
-}
-var ChildProcessError = class extends Error {
-  code;
-  stdout;
-  stderr;
-  constructor(code, stdout, stderr) {
-    const stderrSnippet = stderr.trim().slice(0, 500);
-    const stdoutSnippet = stdout.trim().slice(0, 500);
-    const detail = stderrSnippet || stdoutSnippet || "(no output)";
-    super(`Exit code ${code}: ${detail}`);
-    this.name = "ChildProcessError";
-    this.code = code;
-    this.stdout = stdout;
-    this.stderr = stderr;
-  }
-};
-async function execFilePromiseLong(cmd, args, opts) {
-  const { spawn: sp } = await import("child_process");
-  return new Promise((resolve, reject) => {
-    const child = sp(cmd, args, {
-      cwd: opts?.cwd,
-      stdio: [opts?.stdin === "ignore" ? "ignore" : "pipe", "pipe", "pipe"],
-      ...opts?.env ? { env: opts.env } : {}
-    });
-    if (opts?.onSpawn && typeof child.pid === "number") {
-      try {
-        opts.onSpawn(child.pid);
-      } catch {
-      }
-    }
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (d) => {
-      stdout += d.toString();
-    });
-    child.stderr?.on("data", (d) => {
-      stderr += d.toString();
-    });
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(new Error(`Timed out after ${opts?.timeout ?? 12e4}ms`));
-    }, opts?.timeout ?? 12e4);
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (opts?.onExit && typeof child.pid === "number") {
-        try {
-          opts.onExit(child.pid);
-        } catch {
-        }
-      }
-      if (code !== 0) reject(new ChildProcessError(code, stdout, stderr));
-      else resolve({ stdout, stderr });
-    });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
 // src/lib/manager/restart-timing.ts
 var pendingRequested = /* @__PURE__ */ new Map();
 var tracks = /* @__PURE__ */ new Map();
@@ -4188,9 +4074,9 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync7, rmSync as rmSync3 } from "fs";
-import { join as join15 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync6, rmSync as rmSync3 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir6 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -4202,10 +4088,10 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join15(homedir7(), ".claude");
+    const claudeDir = join14(homedir6(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join15(claudeDir, filename);
-      if (existsSync7(p)) {
+      const p = join14(claudeDir, filename);
+      if (existsSync6(p)) {
         try {
           rmSync3(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -4219,8 +4105,8 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync8, readFileSync as readFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import { join as join15 } from "path";
 var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
@@ -4356,12 +4242,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join16(process.cwd(), "skills", skillId, "SKILL.md"),
-      join16(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join15(process.cwd(), "skills", skillId, "SKILL.md"),
+      join15(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync8(candidate)) {
-        const content = readFileSync14(candidate, "utf-8");
+      if (existsSync7(candidate)) {
+        const content = readFileSync13(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -4502,19 +4388,19 @@ function formatBoardForPrompt(items, template) {
 }
 
 // src/lib/manager/kanban/nudge-state-cache.ts
-import { existsSync as existsSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { join as join16 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join17(configDir, CACHE_FILENAME2);
+  return join16(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
-  if (!existsSync9(path)) return;
+  if (!existsSync8(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf-8"));
+    parsed = JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return;
   }
@@ -4545,7 +4431,7 @@ function saveKanbanNudgeState(source, configDir) {
 }
 
 // src/lib/manager/kanban/notify.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 async function enqueueKanbanNotice(opts) {
   try {
     const res = await api.post(
@@ -4560,7 +4446,7 @@ async function enqueueKanbanNotice(opts) {
     return res.ok === true;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash7("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash6("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice enqueue failed for agent_id=${opts.agentId} error_id=${errId}`);
     return false;
   }
@@ -4575,7 +4461,7 @@ async function cancelKanbanNotice(agentId) {
     return typeof res.cancelled === "number" ? res.cancelled : 0;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash7("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash6("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice cancel failed for agent_id=${agentId} error_id=${errId}`);
     return null;
   }
@@ -4981,7 +4867,7 @@ function deriveScheduledTaskNotify(task) {
 }
 
 // src/lib/manager/scheduler/runs.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 async function startRun(opts) {
   try {
     const res = await api.post(
@@ -4996,7 +4882,7 @@ async function startRun(opts) {
     };
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash8("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash7("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] start failed for agent_id=${opts.agent_id} source_type=${opts.source_type} error_id=${errId}`);
     return { run_id: null, kanban_item_id: null };
   }
@@ -5013,7 +4899,7 @@ async function finishRun(runId, outcome, options = {}) {
     });
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash8("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash7("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] finish failed for run_id=${runId} outcome=${outcome} error_id=${errId}`);
   }
 }
@@ -5030,7 +4916,7 @@ async function fetchPriorScheduledRuns(agentId, taskId) {
     return rows.filter((r) => typeof r.output_text === "string" && r.output_text.length > 0).map((r) => ({ startedAt: r.started_at, output: r.output_text }));
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash8("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash7("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
     return [];
   }
@@ -5079,10 +4965,10 @@ function closeScheduledRunsForCode(codeName, outcome, reason) {
 }
 
 // src/lib/manager/scheduler/kanban-route.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { writeFileSync as writeFileSync8, renameSync } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join18 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join17 } from "path";
 
 // src/lib/manager/delivery/scheduled-output.ts
 async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
@@ -5386,7 +5272,7 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join18(homedir8(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join17(homedir7(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
     writeFileSync8(tmp, JSON.stringify(marker), "utf8");
@@ -5488,24 +5374,24 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
       const assertion = parseDeliverAssertion(rawOutput);
       if (!assertion.deliver) {
         const trimmed = (rawOutput ?? "").trim();
-        const outputHash = trimmed.length === 0 ? "empty" : createHash9("sha256").update(trimmed).digest("hex").slice(0, 12);
+        const outputHash = trimmed.length === 0 ? "empty" : createHash8("sha256").update(trimmed).digest("hex").slice(0, 12);
         log(`[claude-scheduler] Suppressed by delivery_policy=conditional for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 ${assertion.vacuous ? "deliver marker had a vacuous reason" : "no deliver marker"}; output_len=${trimmed.length} output_hash=${outputHash}`);
         if (delivery?.mode === "announce" && delivery.to) {
           await reportDeliveryStatus(agentId, delivery.taskId, { status: "skipped", error_code: "SUPPRESSED_BY_POLICY" });
         }
         return { ok: true };
       }
-      const reasonHash = createHash9("sha256").update(assertion.reason ?? "").digest("hex").slice(0, 12);
+      const reasonHash = createHash8("sha256").update(assertion.reason ?? "").digest("hex").slice(0, 12);
       log(`[claude-scheduler] Delivering conditional run for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent asserted a concrete trigger (reason_len=${(assertion.reason ?? "").length} reason_hash=${reasonHash})`);
       rawOutput = assertion.deliverable;
     }
     const classification = classifyOutput(rawOutput);
     if (classification.action === "suppress") {
       const trimmed = (rawOutput ?? "").trim();
-      const outputHash = trimmed.length === 0 ? "empty" : createHash9("sha256").update(trimmed).digest("hex").slice(0, 12);
+      const outputHash = trimmed.length === 0 ? "empty" : createHash8("sha256").update(trimmed).digest("hex").slice(0, 12);
       log(`[claude-scheduler] Suppressing delivery for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 output_len=${trimmed.length} output_hash=${outputHash}`);
       if (classification.suppressedNotes) {
-        const notesHash = createHash9("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
+        const notesHash = createHash8("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
         log(`[claude-scheduler] Suppressed notes for '${codeName}' (task=${delivery?.taskId ?? "n/a"}) \u2014 notes_len=${classification.suppressedNotes.length} notes_hash=${notesHash}`);
       }
       if (delivery?.mode === "announce" && delivery.to) {
@@ -5571,11 +5457,11 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 }
 
 // src/lib/manager/scheduler/execution.ts
-import { createHash as createHash10 } from "crypto";
-import { homedir as homedir9 } from "os";
-import { join as join19 } from "path";
+import { createHash as createHash9 } from "crypto";
+import { homedir as homedir8 } from "os";
+import { join as join18 } from "path";
 function claudePidFilePath() {
-  return join19(homedir9(), ".augmented", "manager-claude-pids.json");
+  return join18(homedir8(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -5595,10 +5481,10 @@ function unregisterClaudeSpawn(pid) {
 }
 async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
-  const stableTasksHash = createHash10("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const boardHash = boardItems.length > 0 ? createHash10("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+  const stableTasksHash = createHash9("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash9("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
   const resolvedModels = resolveModelChain(refreshData);
-  const modelsHash = createHash10("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+  const modelsHash = createHash9("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
   const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
@@ -5635,355 +5521,8 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   }
 }
 
-// src/lib/opencode-session.ts
-import { spawn, execSync } from "child_process";
-import { createServer } from "net";
-import { randomBytes } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync9, rmSync as rmSync4, chmodSync as chmodSync2 } from "fs";
-import { homedir as homedir10, userInfo } from "os";
-import { join as join20, dirname as dirname6 } from "path";
-var OPENCODE_BIN = process.env["AGT_OPENCODE_BIN"]?.trim() || "opencode";
-var sessions = /* @__PURE__ */ new Map();
-var bridges = /* @__PURE__ */ new Map();
-function opencodeTmuxSession(codeName) {
-  return `agt-oc-${codeName}`;
-}
-function opencodePaneLogPath(codeName) {
-  return join20(homedir10(), ".augmented", codeName, "opencode-serve.log");
-}
-function opencodeTranscriptPath(codeName) {
-  return join20(dirname6(opencodePaneLogPath(codeName)), "opencode-transcript.json");
-}
-var TRANSCRIPT_REFRESH_MS = 3e3;
-var TRANSCRIPT_MAX_MESSAGES = 100;
-var transcriptTimers = /* @__PURE__ */ new Map();
-function pickNewestSession(sessions2) {
-  let newest = null;
-  let newestT = Number.NEGATIVE_INFINITY;
-  for (const s of sessions2) {
-    const t = s.updated ?? s.created ?? 0;
-    if (t >= newestT) {
-      newestT = t;
-      newest = s;
-    }
-  }
-  return newest;
-}
-async function refreshOpencodeTranscript(codeName) {
-  const session = sessions.get(codeName);
-  if (!session || session.status !== "running" || !session.port || !session.password) return;
-  const client2 = new HttpOpencodeClient({
-    baseUrl: baseUrlFor(session.port),
-    password: session.password,
-    requestTimeoutMs: 8e3
-  });
-  let transcript;
-  try {
-    const newest = pickNewestSession(await client2.listSessions());
-    transcript = newest ? buildOpencodeTranscript({
-      sessionId: newest.id,
-      sessionTitle: newest.title ?? null,
-      messages: await client2.getStructuredMessages(newest.id),
-      capturedAt: Date.now(),
-      redact: redactForDiskLog,
-      maxMessages: TRANSCRIPT_MAX_MESSAGES
-    }) : emptyOpencodeTranscript(Date.now());
-  } catch {
-    return;
-  }
-  try {
-    const target = opencodeTranscriptPath(codeName);
-    mkdirSync7(dirname6(target), { recursive: true });
-    writeFileSync9(target, JSON.stringify(transcript), { mode: 384 });
-    try {
-      chmodSync2(target, 384);
-    } catch {
-    }
-  } catch {
-  }
-}
-function startTranscriptRefresher(codeName) {
-  if (transcriptTimers.has(codeName)) return;
-  const timer = setInterval(() => {
-    void refreshOpencodeTranscript(codeName);
-  }, TRANSCRIPT_REFRESH_MS);
-  timer.unref?.();
-  transcriptTimers.set(codeName, timer);
-  void refreshOpencodeTranscript(codeName);
-}
-function stopTranscriptRefresher(codeName) {
-  const timer = transcriptTimers.get(codeName);
-  if (timer) {
-    clearInterval(timer);
-    transcriptTimers.delete(codeName);
-  }
-}
-function readProvisionedOpencodeModel(agentDir) {
-  return readOpencodeModelString(join20(agentDir, "provision", "opencode.json"));
-}
-function readOpencodeModelString(configPath) {
-  try {
-    const parsed = JSON.parse(readFileSync16(configPath, "utf-8"));
-    return typeof parsed.model === "string" ? parsed.model : null;
-  } catch {
-    return null;
-  }
-}
-function readOpencodeModelFromConfigDir(configDir) {
-  return parseOpencodeModelRef(readOpencodeModelString(join20(configDir, "opencode.json")));
-}
-function materializeEnvPlaceholders(raw, env) {
-  return raw.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (whole, name) => {
-    const v = env[name];
-    return typeof v === "string" && v.length > 0 ? v : whole;
-  });
-}
-var MATERIALIZED_CONFIG_BASENAME = "opencode.jsonc";
-function writeMaterializedOpencodeConfig(codeName, projectDir, serveEnv, log2) {
-  const target = join20(projectDir, MATERIALIZED_CONFIG_BASENAME);
-  let raw;
-  try {
-    raw = readFileSync16(join20(projectDir, "opencode.json"), "utf-8");
-  } catch {
-    try {
-      if (existsSync10(target)) rmSync4(target);
-    } catch {
-    }
-    return true;
-  }
-  try {
-    writeFileSync9(target, materializeEnvPlaceholders(raw, serveEnv), { mode: 384 });
-  } catch (err) {
-    log2(`[opencode-session] failed to write materialized opencode.jsonc for '${codeName}': ${err.message}`);
-    return false;
-  }
-  try {
-    chmodSync2(target, 384);
-  } catch {
-  }
-  return true;
-}
-function baseUrlFor(port) {
-  return `http://127.0.0.1:${port}`;
-}
-function findFreePort() {
-  return new Promise((resolve, reject) => {
-    const srv = createServer();
-    srv.on("error", reject);
-    srv.listen(0, "127.0.0.1", () => {
-      const addr = srv.address();
-      if (addr && typeof addr === "object") {
-        const { port } = addr;
-        srv.close(() => resolve(port));
-      } else {
-        srv.close(() => reject(new Error("could not allocate a port")));
-      }
-    });
-  });
-}
-async function startOpencodeSession(config2) {
-  const { codeName, log: log2 } = config2;
-  const existing = sessions.get(codeName);
-  if (existing && existing.status === "running") return existing;
-  const restartCount = existing?.restartCount ?? 0;
-  if (existing?.status === "crashed" && existing.startedAt) {
-    const backoffMs = Math.min(5e3 * Math.pow(2, restartCount), 6e4);
-    if (Date.now() - existing.startedAt < backoffMs) return existing;
-  }
-  if (config2.isolated) {
-    log2(
-      `[opencode-session] refusing to spawn '${codeName}': Docker isolation requested but the opencode container runtime is not implemented yet (ADR-0047). Not running unisolated on a multi-tenant host.`
-    );
-    const blocked = {
-      codeName,
-      startedAt: Date.now(),
-      restartCount: restartCount + 1,
-      status: "crashed",
-      port: null,
-      password: null,
-      lastFailureTail: "opencode isolation not implemented (ADR-0047)",
-      model: null
-    };
-    sessions.set(codeName, blocked);
-    return blocked;
-  }
-  const session = {
-    codeName,
-    startedAt: null,
-    restartCount,
-    status: "starting",
-    port: null,
-    password: null,
-    lastFailureTail: existing?.lastFailureTail ?? null,
-    // ENG-7931: parse the resolved model from the provisioned opencode.json
-    // (config.projectDir IS the provision dir the serve reads) so the bridge can
-    // pass it explicitly on session-create + prompt.
-    model: readOpencodeModelFromConfigDir(config2.projectDir)
-  };
-  sessions.set(codeName, session);
-  try {
-    await spawnServe(config2, session);
-  } catch (err) {
-    log2(`[opencode-session] failed to start '${codeName}': ${err.message}`);
-    session.status = "crashed";
-    session.startedAt = Date.now();
-    session.restartCount++;
-  }
-  return session;
-}
-async function spawnServe(config2, session) {
-  const { codeName, projectDir, log: log2 } = config2;
-  if (!existsSync10(join20(projectDir, "opencode.json"))) {
-    log2(`[opencode-session] warning: no opencode.json in ${projectDir} for '${codeName}' (provisioning may not have run)`);
-  }
-  const tmuxSession = opencodeTmuxSession(codeName);
-  const port = await findFreePort();
-  const password = randomBytes(24).toString("base64url");
-  try {
-    execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-  } catch {
-  }
-  mkdirSync7(join20(homedir10(), ".augmented", codeName), { recursive: true });
-  const serveEnv = {
-    ...process.env,
-    ...readAgentProviderEnv(codeName),
-    ...stripUndefined(config2.serveEnv ?? {}),
-    OPENCODE_SERVER_PASSWORD: password,
-    HOME: process.env.HOME?.trim() || homedir10(),
-    USER: process.env.USER?.trim() || userInfo().username
-  };
-  if (config2.runId) serveEnv["AGT_RUN_ID"] = config2.runId;
-  if (config2.agentTimezone) serveEnv["TZ"] = config2.agentTimezone;
-  if (!writeMaterializedOpencodeConfig(codeName, projectDir, serveEnv, log2)) {
-    throw new Error("failed to write materialized opencode.jsonc (serve would 401 on the {env:\u2026} template)");
-  }
-  const serveCmd = `${OPENCODE_BIN} serve --hostname 127.0.0.1 --port ${port} --print-logs`;
-  log2(`[opencode-session] starting '${tmuxSession}' for '${codeName}' on 127.0.0.1:${port}`);
-  const child = spawn(
-    "tmux",
-    ["new-session", "-d", "-s", tmuxSession, "-c", projectDir, serveCmd],
-    { cwd: projectDir, stdio: ["ignore", "pipe", "pipe"], env: serveEnv }
-  );
-  child.on("close", (code) => {
-    if (code !== 0) {
-      log2(`[opencode-session] failed to create tmux session for '${codeName}' (exit ${code})`);
-      session.status = "crashed";
-      session.startedAt = Date.now();
-      session.restartCount++;
-      return;
-    }
-    log2(`[opencode-session] tmux session '${tmuxSession}' created for '${codeName}'`);
-    setupPaneLog(tmuxSession, codeName, log2);
-  });
-  child.on("error", (err) => {
-    log2(`[opencode-session] failed to start tmux for '${codeName}': ${err.message}`);
-    session.status = "crashed";
-    session.startedAt = Date.now();
-    session.restartCount++;
-  });
-  session.port = port;
-  session.password = password;
-  session.startedAt = Date.now();
-  session.status = "running";
-  session.restartCount = 0;
-  bridges.delete(codeName);
-  stopTranscriptRefresher(codeName);
-  startTranscriptRefresher(codeName);
-}
-function setupPaneLog(tmuxSession, codeName, log2) {
-  const logPath = opencodePaneLogPath(codeName);
-  try {
-    execSync(`tmux pipe-pane -t ${tmuxSession} -o 'cat >> ${logPath}'`, { stdio: "ignore" });
-  } catch (err) {
-    log2(`[opencode-session] could not attach pane log for '${codeName}': ${err.message}`);
-  }
-}
-function readOpencodePaneLogTail(codeName, lines = 40) {
-  const logPath = opencodePaneLogPath(codeName);
-  if (!existsSync10(logPath)) return null;
-  try {
-    const all = readFileSync16(logPath, "utf8").split("\n");
-    return all.slice(-lines).join("\n");
-  } catch {
-    return null;
-  }
-}
-function isOpencodeSessionHealthy(codeName) {
-  const tmuxSession = opencodeTmuxSession(codeName);
-  try {
-    execSync(`tmux has-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function injectOpencodeMessage(codeName, msg, opts = {}) {
-  const session = sessions.get(codeName);
-  if (!session || session.status !== "running" || !session.port || !session.password) {
-    return { status: "declined", reason: "server_not_running" };
-  }
-  const bridge = getBridge(codeName, session.port, session.password);
-  return bridge.handleInbound(msg, { gate: opts.gate, awaitReply: opts.awaitReply });
-}
-function getBridge(codeName, port, password) {
-  const cached = bridges.get(codeName);
-  if (cached && cached.port === port && cached.password === password) return cached.bridge;
-  const client2 = new HttpOpencodeClient({ baseUrl: baseUrlFor(port), password });
-  const model = sessions.get(codeName)?.model ?? null;
-  const bridge = new OpencodeInboundBridge({
-    client: client2,
-    sessionDefaults: model ? { model } : void 0
-  });
-  bridges.set(codeName, { port, password, bridge });
-  return bridge;
-}
-function stopOpencodeSession(codeName, log2) {
-  const tmuxSession = opencodeTmuxSession(codeName);
-  try {
-    execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-    log2(`[opencode-session] stopped '${tmuxSession}' for '${codeName}'`);
-  } catch {
-  }
-  stopTranscriptRefresher(codeName);
-  bridges.delete(codeName);
-  const session = sessions.get(codeName);
-  if (session) {
-    session.status = "stopped";
-    session.port = null;
-    session.password = null;
-  }
-}
-function stripUndefined(env) {
-  const out = {};
-  for (const [k, v] of Object.entries(env)) if (v !== void 0) out[k] = v;
-  return out;
-}
-var PROVIDER_KEY_RE = /^[A-Z][A-Z0-9_]*_API_KEY$/;
-function readAgentProviderEnv(codeName, dir) {
-  const file = join20(dir ?? join20(homedir10(), ".augmented", codeName), ".env");
-  const out = {};
-  try {
-    if (!existsSync10(file)) return out;
-    for (const raw of readFileSync16(file, "utf-8").split("\n")) {
-      const line = raw.trim();
-      if (!line || line.startsWith("#")) continue;
-      const eq = line.indexOf("=");
-      if (eq <= 0) continue;
-      const key = line.slice(0, eq).trim();
-      if (!PROVIDER_KEY_RE.test(key)) continue;
-      let val = line.slice(eq + 1).trim();
-      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
-        val = val.slice(1, -1);
-      }
-      out[key] = val;
-    }
-  } catch {
-  }
-  return out;
-}
-
 // src/lib/opencode-slack-ingest.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 
 // ../../packages/core/dist/channels/slack-rich-text.js
 var MAX_DEPTH = 12;
@@ -6919,7 +6458,7 @@ function startSlackIngest(config2) {
 // src/lib/opencode-slack-ingest.ts
 var ingests = /* @__PURE__ */ new Map();
 function fingerprint(params) {
-  return createHash11("sha256").update(
+  return createHash10("sha256").update(
     JSON.stringify({
       appToken: params.appToken,
       botToken: params.botToken,
@@ -7000,7 +6539,7 @@ function stopAllOpencodeSlackIngests(log2) {
 }
 
 // src/lib/manager/opencode-scheduler.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 var MAX_OPENCODE_SCHED_CONCURRENCY = 2;
 var opencodeSchedulerStates = /* @__PURE__ */ new Map();
 var inFlightOpencodeTasks = /* @__PURE__ */ new Set();
@@ -7014,7 +6553,7 @@ function shouldDeliver(task, reply) {
 }
 async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
   const codeName = agent.code_name;
-  const tasksHash = createHash12("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const tasksHash = createHash11("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   if (knownOpencodeTaskHashes.get(agent.agent_id) !== tasksHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
     const state8 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
@@ -7092,10 +6631,10 @@ async function fireOpencodeScheduledTask(agent, task) {
 }
 
 // src/lib/opencode-telegram-ingest.ts
-import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync17, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync10 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join21 } from "path";
+import { join as join19 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -7628,7 +7167,7 @@ function anySignal(signals) {
 // src/lib/opencode-telegram-ingest.ts
 var ingests2 = /* @__PURE__ */ new Map();
 function fingerprint2(params) {
-  return createHash13("sha256").update(
+  return createHash12("sha256").update(
     JSON.stringify({
       botToken: params.botToken,
       allowedChats: [...params.allowedChats].sort(),
@@ -7643,7 +7182,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join21(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join19(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -7652,7 +7191,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
     load() {
       if (!filePath) return 0;
       try {
-        const parsed = JSON.parse(readFileSync17(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync15(filePath, "utf-8"));
         if (currentBotId != null && typeof parsed?.bot_id === "number" && parsed.bot_id !== currentBotId) {
           log2(`[telegram-ingest:${codeName}] offset cursor belongs to a different bot; ignoring (bot swap)`);
           return 0;
@@ -7670,8 +7209,8 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       if (!filePath || !dir) return;
       const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       try {
-        mkdirSync8(dir, { recursive: true, mode: 448 });
-        writeFileSync10(
+        mkdirSync6(dir, { recursive: true, mode: 448 });
+        writeFileSync9(
           tmpPath,
           JSON.stringify({
             offset,
@@ -7685,7 +7224,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       } catch (err) {
         log2(`[telegram-ingest:${codeName}] offset persist failed: ${err instanceof Error ? err.message : String(err)}`);
         try {
-          if (existsSync11(tmpPath)) unlinkSync(tmpPath);
+          if (existsSync9(tmpPath)) unlinkSync(tmpPath);
         } catch {
         }
       }
@@ -7902,24 +7441,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync4, readFileSync as readFileSync18, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join22 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync16, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join20 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join22(homedir11(), ".augmented", "restart-flags");
+  return join20(homedir9(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join22(restartFlagsDir(), `${codeName}.flag`);
+  return join20(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync12(dir)) return [];
+  if (!existsSync10(dir)) return [];
   const out = [];
   for (const entry of readdirSync4(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync18(join22(dir, entry), "utf8");
+      const raw = readFileSync16(join20(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -7937,8 +7476,8 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync12(path)) {
-    rmSync5(path, { force: true });
+  if (existsSync10(path)) {
+    rmSync4(path, { force: true });
   }
 }
 
@@ -9183,15 +8722,15 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync19(join23(projectDir, ".mcp.json"), "utf-8");
-    return createHash14("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    const raw = readFileSync17(join21(projectDir, ".mcp.json"), "utf-8");
+    return createHash13("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync19(join23(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync17(join21(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -9209,7 +8748,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync19(join23(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync17(join21(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -9309,7 +8848,7 @@ async function runAgentSessionToolBindProbes(agent, integrations, projectDir, op
   if (result && result.rebindCandidates.length > 0 && hostFlagStore().getBoolean("session-tool-rebind")) {
     let mcpJsonForRebind = null;
     try {
-      mcpJsonForRebind = JSON.parse(readFileSync19(join23(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync17(join21(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -9438,7 +8977,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync19(join23(projectDir, ".env.integrations"), "utf-8")
+      readFileSync17(join21(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -9532,7 +9071,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.360" : "dev";
+var agtCliVersion = true ? "0.28.362" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9545,7 +9084,7 @@ function resolveBrewPath(execFileSync2) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync13(path)) return path;
+    if (existsSync11(path)) return path;
   }
   return null;
 }
@@ -9555,7 +9094,7 @@ function claudeBinaryInstalled(execFileSync2) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync13(path))) return true;
+  if (canonical.some((path) => existsSync11(path))) return true;
   try {
     execFileSync2("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -9591,7 +9130,7 @@ async function ensureToolkitCli(toolkitSlug) {
   }
   const { binary, installer, package: pkg, script } = integration.cli_tool;
   const resolvedInstaller = installer ?? "manual";
-  const { execFileSync: execFileSync2, execSync: execSync2 } = await import("child_process");
+  const { execFileSync: execFileSync2, execSync } = await import("child_process");
   try {
     execFileSync2("which", [binary], { timeout: 5e3, stdio: "pipe" });
     toolkitCliEnsured.add(toolkitSlug);
@@ -9627,7 +9166,7 @@ async function ensureToolkitCli(toolkitSlug) {
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      brewBinDir = dirname7(brewPath);
+      brewBinDir = dirname5(brewPath);
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
@@ -9642,7 +9181,7 @@ async function ensureToolkitCli(toolkitSlug) {
         return;
       }
       log(`[toolkit-install] ${toolkitSlug}: running declared install script\u2026`);
-      execSync2(script, { timeout: 18e4, stdio: "pipe" });
+      execSync(script, { timeout: 18e4, stdio: "pipe" });
     }
   } catch (err) {
     const e = err;
@@ -9666,8 +9205,8 @@ async function ensureToolkitCli(toolkitSlug) {
 }
 function runAsync(cmd, args, opts) {
   return new Promise((resolve, reject) => {
-    import("child_process").then(({ spawn: spawn2 }) => {
-      const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"], cwd: opts.cwd });
+    import("child_process").then(({ spawn }) => {
+      const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], cwd: opts.cwd });
       let stdout = "";
       let stderr = "";
       let settled = false;
@@ -9710,8 +9249,8 @@ function claudeManagedSettingsPath() {
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync13(path)) {
-      const raw = readFileSync19(path, "utf-8").trim();
+    if (existsSync11(path)) {
+      const raw = readFileSync17(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -9727,8 +9266,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     }
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
-    mkdirSync10(dirname7(path), { recursive: true });
-    writeFileSync12(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync8(dirname5(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -9766,7 +9305,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync2("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join23(prefix, "bin");
+      const npmBin = join21(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -9823,11 +9362,11 @@ async function ensureFrameworkBinary(frameworkId) {
       log(`Claude Code install failed: ${err.message}`);
       return;
     }
-    const brewBinDir = dirname7(brewPath);
+    const brewBinDir = dirname5(brewPath);
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync13("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync11("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -9883,7 +9422,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join23(homedir12(), ".augmented", ".last-self-update-applied");
+  return join21(homedir10(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -9909,7 +9448,7 @@ async function checkAndUpdateCli(opts) {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return "noop";
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join23(homedir12(), ".augmented", ".last-update-check");
+    const markerPath = join21(homedir10(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -10254,14 +9793,14 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync13(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join23(homedir12(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync11(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join21(homedir10(), ".augmented");
   try {
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync8(dir, { recursive: true });
   } catch {
   }
-  const p = join23(dir, ".eval-empty-mcp.json");
-  writeFileSync12(p, JSON.stringify({ mcpServers: {} }));
+  const p = join21(dir, ".eval-empty-mcp.json");
+  writeFileSync11(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -10286,7 +9825,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir12(),
+    cwd: homedir10(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -10352,10 +9891,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join23(config?.configDir ?? join23(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join21(config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join23(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -10407,7 +9946,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join23(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -10415,7 +9954,7 @@ function channelQuarantineStore() {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join23(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join21(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -10482,13 +10021,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync13 } = await import("fs");
-  const skillsDir = join23(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join23(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync12 } = await import("fs");
+  const skillsDir = join21(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join21(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync6(skillsDir).sort()) {
-    const skillFile = join23(skillsDir, dir, "SKILL.md");
+    const skillFile = join21(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -10530,7 +10069,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync13(claudeMdPath, next, "utf-8");
+    writeFileSync12(claudeMdPath, next, "utf-8");
     log2(`Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)`);
   }
 }
@@ -10551,7 +10090,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-7XG63YFS.js");
+      const { collectDiagnostics } = await import("../persistent-session-7VMIE4G4.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -10650,7 +10189,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-7XG63YFS.js");
+      const { collectDiagnostics } = await import("../persistent-session-7VMIE4G4.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -10671,8 +10210,8 @@ async function pollCycle() {
       }
       let osUsername;
       try {
-        const { userInfo: userInfo2 } = await import("os");
-        osUsername = userInfo2().username;
+        const { userInfo } = await import("os");
+        osUsername = userInfo().username;
       } catch {
       }
       let claudeAuth = null;
@@ -10680,7 +10219,7 @@ async function pollCycle() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash14("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash13("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state6.agents.some(
@@ -10805,7 +10344,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-JV6PRDKD.js");
+      } = await import("../responsiveness-probe-XJ7DQX4M.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -10837,7 +10376,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-JV6PRDKD.js");
+        } = await import("../responsiveness-probe-XJ7DQX4M.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-HYOOQV4A.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -10926,13 +10465,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync19(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync17(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join23(homedir12(), ".augmented", codeName);
-                  if (existsSync13(wedgeHome)) {
+                  const wedgeHome = join21(homedir10(), ".augmented", codeName);
+                  if (existsSync11(wedgeHome)) {
                     atomicWriteFileSync(
-                      join23(wedgeHome, "watchdog-give-up.json"),
+                      join21(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -11181,7 +10720,7 @@ async function pollCycle() {
         } catch {
         }
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir = join23(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join21(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -11268,10 +10807,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join23(homedir12(), ".augmented", codeName);
-          if (!existsSync13(dir)) return;
+          const dir = join21(homedir10(), ".augmented", codeName);
+          if (!existsSync11(dir)) return;
           atomicWriteFileSync(
-            join23(dir, "watchdog-give-up.json"),
+            join21(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -11410,7 +10949,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join23(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join21(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -11456,7 +10995,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync13(agentDir)
+        provisionDirExists: existsSync11(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -11594,7 +11133,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join23(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join21(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   agentRestartTimezoneInputs.set(agent.code_name, {
     agentTimezone: typeof refreshData.agent.timezone === "string" ? refreshData.agent.timezone : null,
@@ -11639,9 +11178,9 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
     const changedFiles = [];
-    mkdirSync10(agentDir, { recursive: true });
+    mkdirSync8(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join23(agentDir, artifact.relativePath);
+      const filePath = join21(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -11660,8 +11199,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join23(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync19(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join21(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync17(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -11679,7 +11218,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync19(filePath, "utf-8");
+          existingRaw = readFileSync17(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -11701,26 +11240,26 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync13(join23(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync11(join21(agentDir, "CHARTER.md"));
       const verb = isFirst ? "Provisioning" : "Updating";
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        const filePath = join23(agentDir, file.relativePath);
-        mkdirSync10(dirname7(filePath), { recursive: true });
+        const filePath = join21(agentDir, file.relativePath);
+        mkdirSync8(dirname5(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync12(filePath, file.content);
+          writeFileSync11(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join23(agentDir, ".claude", "skills");
-        if (existsSync13(provSkillsDir)) {
+        const provSkillsDir = join21(agentDir, ".claude", "skills");
+        if (existsSync11(provSkillsDir)) {
           for (const folder of readdirSync5(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync6(join23(provSkillsDir, folder), { recursive: true });
+                rmSync5(join21(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -11733,7 +11272,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join23(agentDir, file));
+        const h = hashFile(join21(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -11751,14 +11290,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join23(agentDir, ".claude", "workflows");
-        if (existsSync13(provWorkflowsDir)) {
+        const provWorkflowsDir = join21(agentDir, ".claude", "workflows");
+        if (existsSync11(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
           for (const file of readdirSync5(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync6(join23(provWorkflowsDir, file));
+              rmSync5(join21(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -11837,10 +11376,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync13(agentDir)) {
+  if (written && existsSync11(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join23(agentDir, file));
+      const localHash = hashFile(join21(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -11851,7 +11390,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join23(agentDir, file));
+          localHashes[file] = hashFile(join21(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -12038,15 +11577,15 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join23(homedir12(), ".augmented", agent.code_name);
-        mkdirSync10(agentAugmentedDir, { recursive: true });
+        const agentAugmentedDir = join21(homedir10(), ".augmented", agent.code_name);
+        mkdirSync8(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
           at: (/* @__PURE__ */ new Date()).toISOString(),
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join23(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join21(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -12122,7 +11661,7 @@ async function processAgent(agent, agentStates) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash14("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash13("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const msteamsBehaviourRestrictive = isMsTeamsBehaviourRestrictive(behaviourSubset);
       const behaviourDecision = decideSenderPolicyRestart({
@@ -12178,7 +11717,7 @@ async function processAgent(agent, agentStates) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash14("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash13("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourRestrictive = isSlackBehaviourRestrictive(slackBehaviourSubset);
       const slackBehaviourDecision = decideSenderPolicyRestart({
@@ -12235,24 +11774,24 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join23(homedir12(), ".augmented", agent.code_name, "project");
-      mkdirSync10(agentProvisionDir, { recursive: true });
-      mkdirSync10(projectDir, { recursive: true });
-      const provisionMcpPath = join23(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join23(projectDir, ".mcp.json");
+      const projectDir = join21(homedir10(), ".augmented", agent.code_name, "project");
+      mkdirSync8(agentProvisionDir, { recursive: true });
+      mkdirSync8(projectDir, { recursive: true });
+      const provisionMcpPath = join21(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join21(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync19(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync17(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join23(homedir12(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join21(homedir10(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
         return typeof tz === "string" && tz.trim() !== "" ? tz.trim() : void 0;
       })();
-      if (existsSync13(localDirectChatChannel)) {
+      if (existsSync11(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -12272,7 +11811,7 @@ async function processAgent(agent, agentStates) {
           // ~/.augmented/<codeName>/.current-turn-initiator.json. Note getAgentDir
           // returns the agent root (NOT the /provision subdir `agentDir` points at),
           // so it byte-matches the broker readers' path.
-          AGT_TURN_INITIATOR_FILE: join23(
+          AGT_TURN_INITIATOR_FILE: join21(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -12292,10 +11831,10 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join23(projectDir, ".mcp-channels.json");
-      if (existsSync13(staleChannelsPath)) {
+      const staleChannelsPath = join21(projectDir, ".mcp-channels.json");
+      if (existsSync11(staleChannelsPath)) {
         try {
-          rmSync6(staleChannelsPath, { force: true });
+          rmSync5(staleChannelsPath, { force: true });
         } catch {
         }
       }
@@ -12382,7 +11921,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join23(homedir12(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join21(homedir10(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -12393,7 +11932,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join23(homedir12(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join21(homedir10(), ".augmented", agent.code_name, "project");
         probeRan = await runAgentSessionToolBindProbes(agent, integrations, probeProjectDir, { forceDue });
       } catch (err) {
         log(`Session-tool-bind probe failed for '${agent.code_name}': ${err.message}`);
@@ -12406,9 +11945,9 @@ async function processAgent(agent, agentStates) {
     }
     if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
       const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
-      if (mcpPath && existsSync13(mcpPath)) {
+      if (mcpPath && existsSync11(mcpPath)) {
         try {
-          const cfg = JSON.parse(readFileSync19(mcpPath, "utf-8"));
+          const cfg = JSON.parse(readFileSync17(mcpPath, "utf-8"));
           const expectedRemoteKeys = new Set(
             integrations.map((i) => i.definition_id)
           );
@@ -12452,11 +11991,11 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join23(homedir12(), ".augmented", agent.code_name, "project");
-        const envIntPath = join23(projectDir, ".env.integrations");
+        const projectDir = join21(homedir10(), ".augmented", agent.code_name, "project");
+        const envIntPath = join21(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync19(envIntPath, "utf-8");
+          preWriteEnv = readFileSync17(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -12468,9 +12007,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join23(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync19(envIntPath, "utf-8");
-            const mcpContent = readFileSync19(projectMcpPath, "utf-8");
+            const projectMcpPath = join21(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync17(envIntPath, "utf-8");
+            const mcpContent = readFileSync17(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -12547,10 +12086,10 @@ async function processAgent(agent, agentStates) {
           desiredEntries.push({ serverId, url, headers: mcpHeaders, name: tk.toolkit_name });
         }
         const hashBasis = desiredEntries.slice().sort((a, b) => a.serverId.localeCompare(b.serverId)).map((e) => {
-          const headersHash = createHash14("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash13("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash14("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash13("sha256").update(hashBasis).digest("hex").slice(0, 16);
         const prevMcpHash = agentState.knownManagedMcpHashes.get(agent.agent_id);
         const structureHash = managedMcpStructureHash(desiredEntries);
         const prevStructureHash = agentState.knownManagedMcpStructure.get(agent.agent_id);
@@ -12565,15 +12104,15 @@ async function processAgent(agent, agentStates) {
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
-            const urlHash = createHash14("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash13("sha256").update(e.url).digest("hex").slice(0, 12);
             log(`[managed-toolkit] ${agent.code_name}: wrote '${e.name}' (serverId=${e.serverId}, url_hash=${urlHash})`);
           }
           if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync20 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync20(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync18 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync18(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   for (const key of Object.keys(mcpConfig.mcpServers)) {
                     if (isManagedMcpServerKey(key) && !expectedServerIds.has(key)) {
@@ -12674,7 +12213,7 @@ async function processAgent(agent, agentStates) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash15 } = await import("crypto");
+      const { createHash: createHash14 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -12703,7 +12242,7 @@ async function processAgent(agent, agentStates) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash15("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash14("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           const hashKey = `plugin-skill:${agent.agent_id}:${integrationSkillId}`;
           if (agentState.knownSkillHashes.get(hashKey) === contentHash) continue;
           frameworkAdapter.installSkillFiles(agent.code_name, integrationSkillId, bundle.files);
@@ -12715,19 +12254,19 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const { readdirSync: readdirSync6, rmSync: rmSync7 } = await import("fs");
-        const { homedir: homedir13 } = await import("os");
+        const { readdirSync: readdirSync6, rmSync: rmSync6 } = await import("fs");
+        const { homedir: homedir11 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join23(homedir13(), ".augmented", agent.code_name, "skills"),
+          join21(homedir11(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join23(homedir13(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join21(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join23(agentDir, ".claude", "skills")
+          join21(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync13(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync11(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -12741,9 +12280,9 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join23(dir, entry);
-            if (existsSync13(p)) {
-              rmSync7(p, { recursive: true, force: true });
+            const p = join21(dir, entry);
+            if (existsSync11(p)) {
+              rmSync6(p, { recursive: true, force: true });
             }
           }
           log(`Removed ${reason} '${entry}' for '${agent.code_name}' (framework=${frameworkId2})`);
@@ -12761,7 +12300,7 @@ async function processAgent(agent, agentStates) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join23(homedir12(), ".augmented", agent.code_name)
+          join21(homedir10(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -12770,7 +12309,7 @@ async function processAgent(agent, agentStates) {
         const plan = planGlobalSkillSync(
           [...globalSkillsPayload ?? [], ...sharedSkillsPayload ?? []],
           prevIds,
-          (content) => createHash15("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash14("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`),
           { desiredResolved }
         );
@@ -12781,16 +12320,16 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join23(homedir12(), ".augmented", agent.code_name, "skills"),
-            join23(homedir12(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join23(agentDir, ".claude", "skills")
+            join21(homedir10(), ".augmented", agent.code_name, "skills"),
+            join21(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join21(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join23(dir, id);
-              if (existsSync13(p) && existsSync13(join23(p, "SKILL.md"))) {
-                rmSync6(p, { recursive: true, force: true });
+              const p = join21(dir, id);
+              if (existsSync11(p) && existsSync11(join21(p, "SKILL.md"))) {
+                rmSync5(p, { recursive: true, force: true });
                 prunedAny = true;
               }
             }
@@ -12821,7 +12360,7 @@ async function processAgent(agent, agentStates) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash15("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash14("sha256").update(hook.script).digest("hex").slice(0, 12);
             const hookKey = `${agent.agent_id}:${frameworkAdapter.id}:plugin-hook:${slug}:on_install`;
             if (agentState.knownSkillHashes.get(hookKey) === scriptHash) continue;
             const result = await frameworkAdapter.executePluginHook({
@@ -12836,9 +12375,9 @@ async function processAgent(agent, agentStates) {
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
             } else {
-              const stderrHash = createHash15("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash14("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash15("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash14("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
               log(
                 `Integration hook on_install '${slug}' exited ${result.exitCode} for '${agent.code_name}' ` + (missingCmdHash ? `[missing_command_hash=${missingCmdHash}] ` : "") + `[stderr_hash=${stderrHash} stderr_len=${result.stderr.length}]`
               );
@@ -12995,8 +12534,8 @@ async function processAgent(agent, agentStates) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join23(getProjectDir(agent.code_name), ".mcp.json");
-          mcpJsonParsed = JSON.parse(readFileSync19(mcpPath, "utf-8"));
+          const mcpPath = join21(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync17(mcpPath, "utf-8"));
         } catch {
         }
         reapMissingMcpSessions({
@@ -13325,10 +12864,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync13(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync11(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join23(agentDir, file));
+      const h = hashFile(join21(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -13343,7 +12882,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join23(homedir12(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join21(homedir10(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -13413,7 +12952,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join23(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join21(getFramework("opencode").getAgentDir(codeName), "provision");
   const openRouterRaw = refreshData.openrouter ?? null;
   const serveEnv = {
     AGT_HOST: requireHost(),
@@ -13453,8 +12992,8 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join23(projectDir, ".mcp.json");
-  const claudeMdPath = join23(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join21(projectDir, ".mcp.json");
+  const claudeMdPath = join21(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -13612,7 +13151,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       const ctx = getLastFailureContext(codeName);
       const recovery = prepareForRespawn(codeName);
       const tailSummary = !ctx.tail ? "" : KNOWN_SAFE_TAIL_SIGNATURES.has(ctx.signature) ? `; last pane output (${PANE_TAIL_PREVIEW_LINES} of ~20 lines):
-${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash14("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash13("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
       const sigSummary = ctx.signature !== "unknown" ? `; signature=${ctx.signature}` : "";
       const recoverySummary = recovery ? `; recovery=${recovery}` : "";
       log(
@@ -13626,7 +13165,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash14("sha256")
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash14("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash13("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -13775,7 +13314,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash14("sha256")
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash14("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash13("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (stableTasksHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
@@ -13992,7 +13531,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-7XG63YFS.js");
+        const { collectDiagnostics } = await import("../persistent-session-7VMIE4G4.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -14042,7 +13581,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-7XG63YFS.js");
+      const { collectDiagnostics } = await import("../persistent-session-7VMIE4G4.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -14327,9 +13866,9 @@ async function processDirectChatMessage(agent, msg) {
     const useDoorbell = hostFlagStore().getBoolean("direct-chat-doorbell") || isolationMode(agent.codeName) === "docker";
     if (useDoorbell) {
       try {
-        const doorbell = directChatDoorbellPath(agent.agentId, homedir12());
-        mkdirSync10(dirname7(doorbell), { recursive: true });
-        writeFileSync12(doorbell, String(Date.now()));
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir10());
+        mkdirSync8(dirname5(doorbell), { recursive: true });
+        writeFileSync11(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
         return;
       } catch (err) {
@@ -14437,9 +13976,9 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   }
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
-    const doorbell = directChatDoorbellPath(agentId, homedir12());
-    mkdirSync10(dirname7(doorbell), { recursive: true });
-    writeFileSync12(doorbell, String(Date.now()));
+    const doorbell = directChatDoorbellPath(agentId, homedir10());
+    mkdirSync8(dirname5(doorbell), { recursive: true });
+    writeFileSync11(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -14540,7 +14079,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-JX2ZYSZC.js");
+  } = await import("../claude-pair-runtime-LKXINT7K.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));
@@ -14575,12 +14114,12 @@ async function processClaudePairSessions(agents) {
     try {
       if (session.status === "initiating") {
         log(`[claude-pair] spawning pair session ${pairSession} for '${codeName}'`);
-        const spawn2 = await spawnPairSession(pairSession);
-        if (!spawn2.ok) {
+        const spawn = await spawnPairSession(pairSession);
+        if (!spawn.ok) {
           await reportAndCleanup(session.pair_id, {
             status: "failure",
-            error_code: spawn2.error.kind,
-            error_message: spawn2.error.kind === "unknown" ? spawn2.error.message : void 0
+            error_code: spawn.error.kind,
+            error_message: spawn.error.kind === "unknown" ? spawn.error.message : void 0
           });
           continue;
         }
@@ -14790,8 +14329,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join23(configDir, agent.code_name, "project");
-  const memoryDir = join23(projectDir, "memory");
+  const projectDir = join21(configDir, agent.code_name, "project");
+  const memoryDir = join21(projectDir, "memory");
   const isFreshSync = pendingFreshMemorySync.has(agent.agent_id);
   if (isFreshSync) {
     log2(`[memory-sync] Fresh-sync requested for '${agent.code_name}' \u2014 pulling DB first`);
@@ -14802,15 +14341,15 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync13(memoryDir)) {
+  if (existsSync11(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
     for (const file of readdirSync5(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync19(join23(memoryDir, file), "utf-8");
-        const fileHash = createHash14("sha256").update(raw).digest("hex").slice(0, 16);
+        const raw = readFileSync17(join21(memoryDir, file), "utf-8");
+        const fileHash = createHash13("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
         const parsed = parseMemoryFile(raw, file.replace(/\.md$/, ""));
@@ -14834,7 +14373,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync19(join23(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync17(join21(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -14847,29 +14386,29 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync13(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash14("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localFiles = existsSync11(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localListHash = createHash13("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
   try {
     const dbMemories = await api.post("/host/memories", {
       agent_id: agent.agent_id
     });
-    const responseHash = createHash14("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
+    const responseHash = createHash13("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return true;
     }
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync10(memoryDir, { recursive: true });
+      mkdirSync8(memoryDir, { recursive: true });
       let written = 0;
       let overwritten = 0;
       for (let i = 0; i < dbMemories.memories.length; i++) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join23(memoryDir, `${slug}.md`);
+        const filePath = join21(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -14878,23 +14417,23 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync13(filePath)) {
+        if (existsSync11(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync19(filePath, "utf-8");
+            existing = readFileSync17(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync12(filePath, desired);
+          writeFileSync11(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync12(filePath, desired);
+          writeFileSync11(filePath, desired);
           written++;
         }
       }
       if (written > 0 || overwritten > 0) {
         const updatedFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash14("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        lastLocalFileHash.set(agent.agent_id, createHash13("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -14905,9 +14444,9 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync13(agentDir)) {
+  if (existsSync11(agentDir)) {
     try {
-      rmSync6(agentDir, { recursive: true, force: true });
+      rmSync5(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
     } catch (err) {
       log(`Failed to remove provision dir for '${codeName}': ${err.message}`);
@@ -14929,8 +14468,8 @@ var caffeinateProc = null;
 async function startCaffeinate() {
   if (process.platform !== "darwin") return;
   try {
-    const { spawn: spawn2 } = await import("child_process");
-    caffeinateProc = spawn2("caffeinate", ["-dims"], {
+    const { spawn } = await import("child_process");
+    caffeinateProc = spawn("caffeinate", ["-dims"], {
       stdio: "ignore",
       detached: false
     });
@@ -15078,8 +14617,8 @@ async function killAllAgtTmuxSessions() {
       ["list-sessions", "-F", "#{session_name}"],
       { timeout: 2e3, stdin: "ignore" }
     );
-    const sessions2 = output.trim().split("\n").filter((s) => s.startsWith("agt-"));
-    for (const session of sessions2) {
+    const sessions = output.trim().split("\n").filter((s) => s.startsWith("agt-"));
+    for (const session of sessions) {
       try {
         await execFilePromiseLong("tmux", ["kill-session", "-t", session], {
           timeout: 2e3,
@@ -15089,8 +14628,8 @@ async function killAllAgtTmuxSessions() {
       } catch {
       }
     }
-    if (sessions2.length > 0) {
-      log(`Cleaned up ${sessions2.length} agt-* tmux session(s)`);
+    if (sessions.length > 0) {
+      log(`Cleaned up ${sessions.length} agt-* tmux session(s)`);
     }
   } catch {
   }
@@ -15142,8 +14681,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync13(stateFile)) {
-      const raw = readFileSync19(stateFile, "utf-8");
+    if (existsSync11(stateFile)) {
+      const raw = readFileSync17(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -15170,7 +14709,7 @@ function startManager(opts) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);
   }
   log(
-    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join23(homedir12(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join21(homedir10(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -15191,7 +14730,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync19(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync17(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -15209,16 +14748,16 @@ async function reapOrphanedClaudePids() {
     },
     looksLikeClaude
   );
-  for (const spawn2 of decision.toKill) {
+  for (const spawn of decision.toKill) {
     try {
-      process.kill(spawn2.pid, "SIGKILL");
+      process.kill(spawn.pid, "SIGKILL");
     } catch (err) {
-      log(`[drain] reaper SIGKILL pid=${spawn2.pid} failed: ${err.message}`);
+      log(`[drain] reaper SIGKILL pid=${spawn.pid} failed: ${err.message}`);
     }
   }
-  for (const spawn2 of decision.pidReusedSkipped) {
+  for (const spawn of decision.pidReusedSkipped) {
     log(
-      `[drain] reaper skipped pid=${spawn2.pid} \u2014 PID reuse suspected (identity probe rejected)`
+      `[drain] reaper skipped pid=${spawn.pid} \u2014 PID reuse suspected (identity probe rejected)`
     );
   }
   log(formatReaperBootLine({
@@ -15288,18 +14827,18 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join23(homedir12(), ".augmented", "_mcp");
-  mkdirSync10(targetDir, { recursive: true });
-  const moduleDir = dirname7(fileURLToPath(import.meta.url));
+  const targetDir = join21(homedir10(), ".augmented", "_mcp");
+  mkdirSync8(targetDir, { recursive: true });
+  const moduleDir = dirname5(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join23(dir, "dist", "mcp");
-    if (existsSync13(join23(candidate, "index.js"))) {
+    const candidate = join21(dir, "dist", "mcp");
+    if (existsSync11(join21(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname7(dir);
+    const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -15310,8 +14849,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync13(p)) return null;
-      return createHash14("sha256").update(readFileSync19(p)).digest("hex");
+      if (!existsSync11(p)) return null;
+      return createHash13("sha256").update(readFileSync17(p)).digest("hex");
     } catch {
       return null;
     }
@@ -15375,9 +14914,9 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join23(mcpSourceDir, file);
-    const dst = join23(targetDir, file);
-    if (!existsSync13(src)) continue;
+    const src = join21(mcpSourceDir, file);
+    const dst = join21(targetDir, file);
+    if (!existsSync11(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -15394,23 +14933,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join23(targetDir, "index.js");
+  const localMcpPath = join21(targetDir, "index.js");
   try {
-    const agentsDir = join23(homedir12(), ".augmented", "agents");
-    if (existsSync13(agentsDir)) {
+    const agentsDir = join21(homedir10(), ".augmented", "agents");
+    if (existsSync11(agentsDir)) {
       for (const entry of readdirSync5(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join23(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join21(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync19(mcpJsonPath, "utf-8");
+            const raw = readFileSync17(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync12(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync11(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }