@integrity-labs/agt-cli 0.28.715 → 0.28.717

package/dist/lib/manager-worker.js

@@ -16,12 +16,14 @@ import {
   deriveMcpServerKey,
   describeStartupCompletion,
   diffEnvIntegrations,
+  drainTranscriptFlushDeps,
   envOnlyRespawnVars,
   exchangeApiKey,
   exchangeFailureKind,
   executeConnectivityProbe,
   extractCommandNotFound,
   findMcpServersUsingVars,
+  flushAgentTranscriptsOnDrain,
   gatherSessionToolBindProbe,
   getApiKey,
   getCachedClaudeAuthMode,
@@ -45,6 +47,7 @@ import {
   provisionSessionStateHook,
   provisionStopHook,
   readEnvNumber,
+  readHostArchiveAddress,
   reapMissingMcpSessions,
   reapStaleMcpChildren,
   reaperRestartBreakerReason,
@@ -54,7 +57,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-VZPXV57A.js";
+} from "../chunk-XSBRGOGL.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -112,7 +115,7 @@ import {
   takeZombieDetection,
   toOpencodeModel,
   writeEgressAllowlist
-} from "../chunk-RPWLPRGP.js";
+} from "../chunk-JN4D7534.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -186,7 +189,6 @@ import {
   parseUsageReport,
   peekCurrentSession,
   pickNewerClassification,
-  readDailySessionPin,
   remoteMcpServerKey,
   resolveAgentTimezone,
   resolveAvatarEnvUrl,
@@ -198,14 +200,14 @@ import {
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   transcriptActivityAgeSeconds
-} from "../chunk-LHYYO4NY.js";
+} from "../chunk-KVR5KNED.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash17 } from "crypto";
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, existsSync as existsSync17, rmSync as rmSync5, readdirSync as readdirSync10, statSync as statSync8, unlinkSync as unlinkSync6, renameSync as renameSync8, utimesSync } from "fs";
+import { createHash as createHash18 } from "crypto";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync16, mkdirSync as mkdirSync12, existsSync as existsSync17, rmSync as rmSync6, readdirSync as readdirSync10, statSync as statSync9, unlinkSync as unlinkSync6, renameSync as renameSync9, utimesSync as utimesSync2 } from "fs";
 
 // src/lib/atomic-file-replace.ts
 import { copyFileSync, renameSync, unlinkSync } from "fs";
@@ -231,8 +233,8 @@ function defaultUnique() {
 
 // src/lib/manager-worker.ts
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join39, dirname as dirname11, delimiter as pathDelimiter } from "path";
-import { homedir as homedir18 } from "os";
+import { join as join39, dirname as dirname10, delimiter as pathDelimiter } from "path";
+import { homedir as homedir17 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/single-flight.ts
@@ -299,288 +301,6 @@ function claudeCodeUpgradeThrottled() {
   }
 }
 
-// src/lib/drain-transcript-flush.ts
-import { existsSync, readdirSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join3, relative, sep } from "path";
-import { spawn } from "child_process";
-
-// src/lib/host-archive-address.ts
-import { readFileSync as readFileSync2 } from "fs";
-var DEFAULT_ARCHIVE_ADDRESS_PATH = "/var/lib/augmented/session-archive-address.json";
-var CACHE_TTL_MS = 5 * 60 * 1e3;
-var cache = /* @__PURE__ */ new Map();
-function str(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function readHostArchiveAddress(path) {
-  const file = path ?? process.env["ARCHIVE_ADDRESS_FILE"]?.trim() ?? process.env["AGT_SESSION_ARCHIVE_ADDRESS_FILE"]?.trim() ?? DEFAULT_ARCHIVE_ADDRESS_PATH;
-  const now = Date.now();
-  const hit = cache.get(file);
-  if (hit && now - hit.at < CACHE_TTL_MS) return hit.value;
-  let value = null;
-  try {
-    const raw = readFileSync2(file, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const obj = parsed;
-      const bucket = str(obj["bucket"]);
-      const keyPrefix = str(obj["key_prefix"]);
-      if (bucket && keyPrefix) {
-        value = {
-          bucket,
-          region: str(obj["region"]),
-          instanceId: str(obj["instance_id"]),
-          keyPrefix
-        };
-      }
-    }
-  } catch {
-    value = null;
-  }
-  cache.set(file, { at: now, value });
-  return value;
-}
-
-// src/lib/drain-transcript-flush.ts
-function sessionsBaseDir() {
-  return join3(homedir2(), ".claude", "projects");
-}
-var PER_FILE_UPLOAD_TIMEOUT_MS = 3e4;
-var UPLOAD_CONCURRENCY = 4;
-var DRAIN_MANIFEST_VERSION = 1;
-var DRAIN_MANIFEST_FILENAME = "_augmented-drain-manifest.json";
-function listJsonlFiles(dir) {
-  if (!existsSync(dir)) return [];
-  const out = [];
-  const walk = (d) => {
-    for (const entry of readdirSync(d, { withFileTypes: true })) {
-      const full = join3(d, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
-    }
-  };
-  try {
-    walk(dir);
-  } catch {
-  }
-  return out;
-}
-function transcriptObjectKey(keyPrefix, baseDir, file) {
-  const rel = relative(baseDir, file).split(sep).join("/");
-  if (!rel || rel.startsWith("../") || rel === "..") return null;
-  return `${keyPrefix.replace(/\/+$/, "")}/${rel}`;
-}
-function drainManifestObjectKey(keyPrefix, baseDir, transcriptDir) {
-  return transcriptObjectKey(keyPrefix, baseDir, join3(transcriptDir, DRAIN_MANIFEST_FILENAME));
-}
-async function flushAgentTranscriptsOnDrain(codeName, deps) {
-  const dir = deps.resolveTranscriptDir(codeName);
-  const files = deps.listTranscripts(dir);
-  if (files.length === 0) {
-    return {
-      status: "no-transcripts",
-      uploaded: 0,
-      failed: 0,
-      total: 0,
-      manifest: "skipped",
-      manifestKey: null
-    };
-  }
-  const address = deps.readAddress();
-  if (!address || !address.bucket || !address.keyPrefix) {
-    deps.log(
-      `[drain-flush] NO S3 ADDRESS for '${codeName}' \u2014 ${files.length} transcript file(s) will NOT be shipped before teardown; this session may be lost (ENG-9491). The host archive address is unresolved (agt-session-archiver has published none).`
-    );
-    return {
-      status: "no-address",
-      uploaded: 0,
-      failed: files.length,
-      total: files.length,
-      manifest: "skipped",
-      manifestKey: null
-    };
-  }
-  const { bucket, keyPrefix, region } = address;
-  let uploaded = 0;
-  let failed = 0;
-  const keys = [];
-  const missing = [];
-  let cursor = 0;
-  const worker = async () => {
-    for (; ; ) {
-      const i = cursor;
-      cursor += 1;
-      if (i >= files.length) return;
-      const file = files[i];
-      const key = transcriptObjectKey(keyPrefix, deps.baseDir, file);
-      if (!key) {
-        failed += 1;
-        missing.push(file);
-        deps.log(
-          `[drain-flush] SKIP '${file}' for '${codeName}' \u2014 outside sessions base dir '${deps.baseDir}', cannot key it (ENG-9491)`
-        );
-        continue;
-      }
-      const res = await deps.uploadFile({ file, bucket, key, region });
-      if (res.ok) {
-        uploaded += 1;
-        keys.push(key);
-      } else {
-        failed += 1;
-        missing.push(file);
-        deps.log(
-          `[drain-flush] UPLOAD FAILED for '${codeName}' '${file}' \u2192 s3://${bucket}/${key}: ${res.detail} (ENG-9491)`
-        );
-      }
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(UPLOAD_CONCURRENCY, files.length) }, () => worker())
-  );
-  const uploadStatus = failed === 0 ? "flushed" : uploaded === 0 ? "failed" : "partial";
-  if (uploadStatus !== "flushed") {
-    deps.log(
-      `[drain-flush] INCOMPLETE for '${codeName}': ${uploaded}/${files.length} transcript file(s) shipped, ${failed} FAILED before teardown \u2014 session data may be lost (ENG-9491).`
-    );
-  }
-  const { manifest, manifestKey } = await writeDrainManifest(codeName, deps, {
-    bucket,
-    keyPrefix,
-    region,
-    transcriptDir: dir,
-    keys,
-    missing,
-    complete: failed === 0
-  });
-  const status = uploadStatus === "flushed" && manifest !== "written" ? "no-manifest" : uploadStatus;
-  return { status, uploaded, failed, total: files.length, manifest, manifestKey };
-}
-async function writeDrainManifest(codeName, deps, ctx) {
-  const manifestKey = drainManifestObjectKey(ctx.keyPrefix, deps.baseDir, ctx.transcriptDir);
-  if (!manifestKey) {
-    deps.log(
-      `[drain-flush] NO MANIFEST for '${codeName}' \u2014 transcript dir '${ctx.transcriptDir}' is outside sessions base dir '${deps.baseDir}', so no manifest key could be computed. Any shipped object is UNRESTORABLE: nothing records the session pin or the source layout (ENG-9566).`
-    );
-    return { manifest: "unkeyable", manifestKey: null };
-  }
-  let layout = null;
-  try {
-    layout = deps.readSourceLayout(codeName);
-  } catch (err) {
-    deps.log(
-      `[drain-flush] could not resolve source layout for '${codeName}': ${err.message} \u2014 manifest will record it as unknown (ENG-9566)`
-    );
-  }
-  let sessionPin = null;
-  try {
-    sessionPin = deps.readSessionPin(codeName);
-  } catch (err) {
-    deps.log(
-      `[drain-flush] could not read the session pin for '${codeName}': ${err.message} \u2014 a restore will not be able to identify the live conversation (ENG-9566)`
-    );
-  }
-  const manifestBody = {
-    version: DRAIN_MANIFEST_VERSION,
-    codeName,
-    writtenAt: deps.now().toISOString(),
-    sourceLayout: layout?.layout ?? null,
-    sourceAgentDir: layout?.agentDir ?? null,
-    sourceTranscriptDir: ctx.transcriptDir,
-    sourceBaseDir: deps.baseDir,
-    bucket: ctx.bucket,
-    keyPrefix: ctx.keyPrefix,
-    keys: ctx.keys,
-    missing: ctx.missing,
-    complete: ctx.complete,
-    sessionPin
-  };
-  const res = await deps.uploadManifest({
-    body: `${JSON.stringify(manifestBody, null, 2)}
-`,
-    bucket: ctx.bucket,
-    key: manifestKey,
-    region: ctx.region
-  });
-  if (!res.ok) {
-    deps.log(
-      `[drain-flush] MANIFEST UPLOAD FAILED for '${codeName}' \u2192 s3://${ctx.bucket}/${manifestKey}: ${res.detail}. ${ctx.keys.length} shipped object(s) are UNRESTORABLE without it (ENG-9566).`
-    );
-    return { manifest: "failed", manifestKey: null };
-  }
-  return { manifest: "written", manifestKey };
-}
-function drainTranscriptFlushDeps(log2) {
-  return {
-    resolveTranscriptDir: (codeName) => sessionTranscriptDir(getProjectDir(codeName)),
-    readAddress: () => readHostArchiveAddress(),
-    listTranscripts: listJsonlFiles,
-    baseDir: sessionsBaseDir(),
-    now: () => /* @__PURE__ */ new Date(),
-    // ENG-9566: derive the layout from the seam's OUTPUT rather than re-running
-    // its lstat. getProjectDir already resolved the codename symlink (or didn't);
-    // if what came back is not under the codename dir, this host is id-keyed.
-    // Observing the resolver keeps a second copy of ADR-0049's rule out of the
-    // tree — the thing host-archive-address.ts's header warns about.
-    readSourceLayout: (codeName) => {
-      const agentDir = dirname3(getProjectDir(codeName));
-      const codeNameDir = join3(homedir2(), ".augmented", codeName);
-      return { layout: agentDir === codeNameDir ? "codename-keyed" : "id-keyed", agentDir };
-    },
-    readSessionPin: (codeName) => readDailySessionPin(codeName),
-    uploadFile: ({ file, bucket, key, region }) => runAwsCp(awsCpArgs(file, bucket, key, region), null),
-    uploadManifest: ({ body, bucket, key, region }) => (
-      // `-` is `aws s3 cp`'s stdin source, so the manifest never touches disk.
-      runAwsCp(
-        [...awsCpArgs("-", bucket, key, region), "--content-type", "application/json"],
-        body
-      )
-    ),
-    log: log2
-  };
-}
-function awsCpArgs(source, bucket, key, region) {
-  const args = ["s3", "cp", source, `s3://${bucket}/${key}`, "--only-show-errors"];
-  if (region) args.push("--region", region);
-  return args;
-}
-function runAwsCp(args, body) {
-  return new Promise((resolve2) => {
-    const child = spawn("aws", args, {
-      stdio: [body === null ? "ignore" : "pipe", "ignore", "pipe"]
-    });
-    let stderr = "";
-    let settled = false;
-    const finish = (r) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer3);
-      resolve2(r);
-    };
-    const timer3 = setTimeout(() => {
-      child.kill("SIGKILL");
-      finish({ ok: false, detail: `aws s3 cp timed out after ${PER_FILE_UPLOAD_TIMEOUT_MS}ms` });
-    }, PER_FILE_UPLOAD_TIMEOUT_MS);
-    child.stderr?.on("data", (d) => {
-      stderr += String(d);
-    });
-    child.on("error", (err) => finish({ ok: false, detail: err.message }));
-    child.on(
-      "close",
-      (code) => finish(
-        code === 0 ? { ok: true, detail: "" } : { ok: false, detail: stderr.trim().slice(0, 500) || `aws exited with code ${code ?? "null"}` }
-      )
-    );
-    if (body !== null) {
-      child.stdin?.on("error", () => {
-      });
-      child.stdin?.end(body);
-    }
-  });
-}
-
 // src/lib/mcp-config-drift.ts
 import { createHash } from "crypto";
 function decideMcpDriftAction(currentHash, knownHash) {
@@ -1007,8 +727,8 @@ function isSlackBehaviourRestrictive(subset) {
 }
 
 // src/lib/onboarding-drive.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3 } from "path";
 var ONBOARDING_REINJECT_INTERVAL_MS = 45 * 6e4;
 var ONBOARDING_MAX_NUDGES = 3;
 var ONBOARDING_MIN_STANDDOWN_AGE_MS = 60 * 6e4;
@@ -1134,7 +854,7 @@ function onboardingNudgeReachedSession(result) {
 }
 function readOnboardingDriveMarker(path) {
   try {
-    const raw = JSON.parse(readFileSync3(path, "utf8"));
+    const raw = JSON.parse(readFileSync2(path, "utf8"));
     if (typeof raw.step === "string" && isOnboardingArea(raw.step) && typeof raw.injectedAtMs === "number" && Number.isFinite(raw.injectedAtMs)) {
       const legacyInjects = typeof raw.nudgeCount === "number" && Number.isFinite(raw.nudgeCount) && raw.nudgeCount >= 1 ? Math.floor(raw.nudgeCount) : 1;
       const hasNewCounters = typeof raw.injectCount === "number" && Number.isFinite(raw.injectCount) && raw.injectCount >= 1;
@@ -1159,7 +879,7 @@ function readOnboardingDriveMarker(path) {
   return null;
 }
 function writeOnboardingDriveMarker(path, marker) {
-  mkdirSync2(dirname4(path), { recursive: true });
+  mkdirSync2(dirname3(path), { recursive: true });
   writeFileSync2(path, JSON.stringify(marker) + "\n", "utf8");
 }
 function clearOnboardingDriveMarker(path) {
@@ -1170,8 +890,8 @@ function clearOnboardingDriveMarker(path) {
 }
 
 // src/lib/channel-quarantine.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 var ESSENTIAL_CHANNEL_KEYS = /* @__PURE__ */ new Set(["direct-chat", "augmented"]);
 var OPTIONAL_CHANNEL_KEYS = /* @__PURE__ */ new Set([
   "telegram",
@@ -1203,7 +923,7 @@ function classifyChannelCriticality(serverKey, entry) {
   return "essential";
 }
 function defaultQuarantinePath(configDir) {
-  return join4(configDir, "channel-quarantine.json");
+  return join3(configDir, "channel-quarantine.json");
 }
 var ChannelQuarantineStore = class {
   path;
@@ -1214,7 +934,7 @@ var ChannelQuarantineStore = class {
   load() {
     if (this.cache) return this.cache;
     try {
-      const raw = readFileSync4(this.path, "utf-8");
+      const raw = readFileSync3(this.path, "utf-8");
       const parsed = JSON.parse(raw);
       this.cache = isQuarantineFile(parsed) ? parsed : {};
     } catch {
@@ -1302,13 +1022,13 @@ function isQuarantineFile(value) {
 }
 
 // src/lib/claude-md-size.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 function measureClaudeMd(configDir, codeName, ceiling = CLAUDE_MD_CONTEXT_ALARM_CHARS) {
   let chars;
   let bytes;
   try {
-    const buf = readFileSync5(join5(configDir, codeName, "project", "CLAUDE.md"));
+    const buf = readFileSync4(join4(configDir, codeName, "project", "CLAUDE.md"));
     chars = buf.toString("utf8").length;
     bytes = buf.length;
   } catch {
@@ -1328,8 +1048,8 @@ function measureClaudeMd(configDir, codeName, ceiling = CLAUDE_MD_CONTEXT_ALARM_
 function measureCoreKnowledgeDescription(configDir, codeName) {
   let text;
   try {
-    text = readFileSync5(
-      join5(configDir, codeName, "project", ".claude", "skills", "core-knowledge", "SKILL.md"),
+    text = readFileSync4(
+      join4(configDir, codeName, "project", ".claude", "skills", "core-knowledge", "SKILL.md"),
       "utf8"
     );
   } catch {
@@ -1363,16 +1083,16 @@ function logClaudeMdCeilingTransition(codeName, report, log2) {
 }
 
 // ../../packages/core/dist/integrations/forwarded-tools-report.js
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 var FORWARDED_TOOLS_REPORT_FILENAME = "forwarded-tools.json";
 function forwardedToolsReportPath(agentDir) {
-  return join6(agentDir, FORWARDED_TOOLS_REPORT_FILENAME);
+  return join5(agentDir, FORWARDED_TOOLS_REPORT_FILENAME);
 }
 function readForwardedToolsReport(agentDir) {
   let raw;
   try {
-    raw = readFileSync6(forwardedToolsReportPath(agentDir), "utf-8");
+    raw = readFileSync5(forwardedToolsReportPath(agentDir), "utf-8");
   } catch {
     return null;
   }
@@ -1959,16 +1679,16 @@ var DependencyRecoveryLedger = class {
 
 // src/lib/mcp-assets-ready.ts
 import { existsSync as nodeExistsSync, readFileSync as nodeReadFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7, resolve, sep as sep2 } from "path";
-function getSharedMcpDir(homeDir = homedir3()) {
-  return join7(homeDir, ".augmented", "_mcp");
+import { homedir as homedir2 } from "os";
+import { join as join6, resolve, sep } from "path";
+function getSharedMcpDir(homeDir = homedir2()) {
+  return join6(homeDir, ".augmented", "_mcp");
 }
 function isPathInsideDir(candidate, dir) {
   const resolvedDir = resolve(dir);
   const resolvedCandidate = resolve(candidate);
   if (resolvedCandidate === resolvedDir) return false;
-  return resolvedCandidate.startsWith(resolvedDir.endsWith(sep2) ? resolvedDir : resolvedDir + sep2);
+  return resolvedCandidate.startsWith(resolvedDir.endsWith(sep) ? resolvedDir : resolvedDir + sep);
 }
 function findMissingMcpBundles(mcpConfigPath, deps = {}) {
   const existsSync18 = deps.existsSync ?? nodeExistsSync;
@@ -2014,8 +1734,8 @@ function formatMissingMcpBundles(missing) {
 }
 
 // src/lib/self-update-coalesce.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname4 } from "path";
 var DEFAULT_SELF_UPDATE_COALESCE_MS = 30 * 60 * 1e3;
 function resolveCoalesceWindowMs(env = process.env) {
   const raw = env.AGT_SELF_UPDATE_COALESCE_MS;
@@ -2024,7 +1744,7 @@ function resolveCoalesceWindowMs(env = process.env) {
   if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_SELF_UPDATE_COALESCE_MS;
   return Math.trunc(parsed);
 }
-function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync7(p, "utf-8")) {
+function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync6(p, "utf-8")) {
   let raw;
   try {
     raw = read(markerPath);
@@ -2037,7 +1757,7 @@ function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) =>
   return v;
 }
 function stampLastSelfUpdateApplied(markerPath, now = Date.now(), write = (p, v) => {
-  mkdirSync3(dirname5(p), { recursive: true });
+  mkdirSync3(dirname4(p), { recursive: true });
   writeFileSync4(p, v);
 }) {
   try {
@@ -2328,11 +2048,11 @@ async function reportModelApiError(opts) {
 }
 
 // src/lib/claude-pid-tracker.ts
-import { existsSync as existsSync2, readFileSync as readFileSync8 } from "fs";
+import { existsSync, readFileSync as readFileSync7 } from "fs";
 function readPidFile(path) {
-  if (!existsSync2(path)) return { version: 1, spawns: [] };
+  if (!existsSync(path)) return { version: 1, spawns: [] };
   try {
-    const raw = JSON.parse(readFileSync8(path, "utf-8"));
+    const raw = JSON.parse(readFileSync7(path, "utf-8"));
     if (raw.version !== 1 || !Array.isArray(raw.spawns)) return { version: 1, spawns: [] };
     const spawns = raw.spawns.filter(
       (s) => !!s && typeof s.pid === "number" && Number.isFinite(s.pid) && s.pid > 0
@@ -2382,14 +2102,14 @@ function formatReaperBootLine(opts) {
 }
 
 // src/lib/direct-chat-delivery.ts
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var DEFAULT_DIRECT_CHAT_MAX_AGE_MS = 30 * 6e4;
 function directChatMaxAgeMs() {
   const raw = parseInt(process.env["AGT_DIRECT_CHAT_MAX_AGE_MS"] ?? "", 10);
   return Number.isFinite(raw) && raw >= 0 ? raw : DEFAULT_DIRECT_CHAT_MAX_AGE_MS;
 }
 function directChatDoorbellPath(agentId, home) {
-  return join8(home, ".augmented", agentId, "direct-chat-doorbell");
+  return join7(home, ".augmented", agentId, "direct-chat-doorbell");
 }
 function isDirectChatMessageExpired(createdAt, nowMs, maxAgeMs) {
   if (!maxAgeMs || maxAgeMs <= 0) return false;
@@ -2400,16 +2120,16 @@ function isDirectChatMessageExpired(createdAt, nowMs, maxAgeMs) {
 }
 
 // src/lib/id-keyed-migration.ts
-import { existsSync as existsSync3, lstatSync, readlinkSync, renameSync as renameSync2 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync2, lstatSync, readlinkSync, renameSync as renameSync2 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
 var ID_KEYED_MIGRATION_FLAG = "id-keyed-layout-migration";
 function agentHasActiveWhatsapp(channelConfigs, codeNameDir) {
   if (channelConfigs && Object.prototype.hasOwnProperty.call(channelConfigs, "whatsapp")) {
     return true;
   }
   try {
-    if (existsSync3(join9(codeNameDir, "whatsapp-pending-inbound"))) return true;
+    if (existsSync2(join8(codeNameDir, "whatsapp-pending-inbound"))) return true;
   } catch {
   }
   return false;
@@ -2421,12 +2141,12 @@ function finishTranscriptMove(oldCwd, newCwd, codeName, log2) {
   let fromExists = false;
   let toExists = false;
   try {
-    fromExists = existsSync3(from);
+    fromExists = existsSync2(from);
   } catch {
   }
   if (!fromExists) return;
   try {
-    toExists = existsSync3(to);
+    toExists = existsSync2(to);
   } catch {
   }
   if (toExists) {
@@ -2439,19 +2159,19 @@ function finishTranscriptMove(oldCwd, newCwd, codeName, log2) {
   log2(`[id-keyed-migration] moved transcript store for '${codeName}' to the id-keyed key`);
 }
 function maybeMigrateAgentToIdKeyedLayout(agent, deps) {
-  const home = deps.home ?? homedir4();
+  const home = deps.home ?? homedir3();
   const { code_name: codeName, agent_id: agentId } = agent;
-  const codeNamePath = join9(home, ".augmented", codeName);
-  const idPath = join9(home, ".augmented", agentId);
-  const oldCwd = join9(home, ".augmented", codeName, "project");
-  const newCwd = join9(idPath, "project");
+  const codeNamePath = join8(home, ".augmented", codeName);
+  const idPath = join8(home, ".augmented", agentId);
+  const oldCwd = join8(home, ".augmented", codeName, "project");
+  const newCwd = join8(idPath, "project");
   let codeNameKind;
   try {
     codeNameKind = lstatSync(codeNamePath).isSymbolicLink() ? "symlink" : "realdir";
   } catch {
     codeNameKind = "absent";
   }
-  const idExists = existsSync3(idPath);
+  const idExists = existsSync2(idPath);
   try {
     if (codeNameKind === "symlink") {
       const target = readlinkSync(codeNamePath);
@@ -2571,8 +2291,8 @@ function collectEnvGates(env) {
 }
 
 // ../../packages/core/dist/direct-chat/cursor-advance-telemetry.js
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 var CURSOR_SHORTFALL_COUNTER_SUFFIX = "-cursor-advance-classifications.json";
 function recordCursorAdvanceOutcome(agentDir, source, route, verdict) {
   if (!agentDir)
@@ -2580,10 +2300,10 @@ function recordCursorAdvanceOutcome(agentDir, source, route, verdict) {
   const key = cursorAdvanceCounterKey(route, verdict);
   if (key === null)
     return;
-  const path = join10(agentDir, `${source}${CURSOR_SHORTFALL_COUNTER_SUFFIX}`);
+  const path = join9(agentDir, `${source}${CURSOR_SHORTFALL_COUNTER_SUFFIX}`);
   const counts = {};
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       for (const [k, v] of Object.entries(parsed)) {
         if (typeof v === "number" && Number.isInteger(v) && v >= 0)
@@ -2600,8 +2320,8 @@ function recordCursorAdvanceOutcome(agentDir, source, route, verdict) {
 }
 
 // src/lib/artifact-stream.ts
-import { join as join11 } from "path";
-import { homedir as homedir5 } from "os";
+import { join as join10 } from "path";
+import { homedir as homedir4 } from "os";
 import { readdir, stat, readFile } from "fs/promises";
 var ARTEFACT_ENTRY_FILE = "index.html";
 function errMessage(err) {
@@ -2686,7 +2406,7 @@ var ArtifactStreamScanner = class {
         return;
       }
       for (const name of names) {
-        const file = join11(this.artifactsDir, name, ARTEFACT_ENTRY_FILE);
+        const file = join10(this.artifactsDir, name, ARTEFACT_ENTRY_FILE);
         const mtime = await this.fsDeps.mtimeMs(file).catch(() => null);
         if (mtime === null) continue;
         if (this.seenMtime.get(name) === mtime) continue;
@@ -2717,7 +2437,7 @@ var ArtifactStreamScanner = class {
   }
 };
 function artifactsDirFor(codeName) {
-  return join11(homedir5(), ".augmented", codeName, "artifacts");
+  return join10(homedir4(), ".augmented", codeName, "artifacts");
 }
 var nodeArtifactFs = {
   async listArtefactNames(artifactsDir) {
@@ -2970,13 +2690,13 @@ async function maybePollHostUsage(deps) {
 // src/lib/claude-account-fingerprint.ts
 import { createHash as createHash6 } from "crypto";
 import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
-import { homedir as homedir7, platform as platform2 } from "os";
-import { dirname as dirname6, join as join13 } from "path";
+import { homedir as homedir6, platform as platform2 } from "os";
+import { dirname as dirname5, join as join12 } from "path";
 
 // src/lib/claude-auth-detect.ts
 import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { homedir as homedir6, platform } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir5, platform } from "os";
+import { join as join11 } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -2991,16 +2711,16 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join12(homedir6(), ".claude", ".credentials.json"),
-    join12(homedir6(), ".claude", "credentials.json")
+    join11(homedir5(), ".claude", ".credentials.json"),
+    join11(homedir5(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
     try {
       const entries = await readdir2("/home", { withFileTypes: true });
       for (const entry of entries.filter((entry2) => entry2.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-        candidates.push(join12("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join12("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join11("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join11("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -3078,13 +2798,13 @@ function parseExpiresAt(raw) {
 
 // src/lib/claude-account-fingerprint.ts
 async function candidateHomes() {
-  const homes = [homedir7()];
+  const homes = [homedir6()];
   const isLinuxRoot = platform2() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
     try {
       const entries = await readdir3("/home", { withFileTypes: true });
       for (const entry of entries.filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-        homes.push(join13("/home", entry.name));
+        homes.push(join12("/home", entry.name));
       }
     } catch {
     }
@@ -3095,7 +2815,7 @@ async function homeOfActiveCredentials() {
   for (const path of await findClaudeCredentialsPaths()) {
     try {
       await readFile3(path, "utf-8");
-      return dirname6(dirname6(path));
+      return dirname5(dirname5(path));
     } catch {
     }
   }
@@ -3104,11 +2824,11 @@ async function homeOfActiveCredentials() {
 async function claudeConfigCandidatePaths() {
   const paths = [];
   const configDir = process.env["CLAUDE_CONFIG_DIR"]?.trim();
-  if (configDir) paths.push(join13(configDir, ".claude.json"));
+  if (configDir) paths.push(join12(configDir, ".claude.json"));
   const activeHome = await homeOfActiveCredentials();
-  if (activeHome) paths.push(join13(activeHome, ".claude.json"));
+  if (activeHome) paths.push(join12(activeHome, ".claude.json"));
   for (const home of await candidateHomes()) {
-    const path = join13(home, ".claude.json");
+    const path = join12(home, ".claude.json");
     if (!paths.includes(path)) paths.push(path);
   }
   return paths;
@@ -3206,10 +2926,10 @@ function diffAuthTuples(recorded, current) {
 
 // src/lib/account-enforcement-marker.ts
 import { mkdirSync as mkdirSync4, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join14 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join13 } from "path";
 function accountEnforcementMarkerPath(codeName) {
-  return join14(homedir8(), ".augmented", codeName, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
+  return join13(homedir7(), ".augmented", codeName, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
 }
 function syncAccountEnforcementMarker(codeName, level, log2 = (m) => process.stderr.write(`${m}
 `), text) {
@@ -3217,8 +2937,8 @@ function syncAccountEnforcementMarker(codeName, level, log2 = (m) => process.std
     clearAccountEnforcementMarker(codeName, log2);
     return;
   }
-  const dir = join14(homedir8(), ".augmented", codeName);
-  const path = join14(dir, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
+  const dir = join13(homedir7(), ".augmented", codeName);
+  const path = join13(dir, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
   const tempPath = `${path}.${process.pid}.tmp`;
   try {
     mkdirSync4(dir, { recursive: true });
@@ -3243,8 +2963,8 @@ function clearAccountEnforcementMarker(codeName, log2 = (m) => process.stderr.wr
 }
 
 // src/lib/token-usage-monitor.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync10, statSync } from "fs";
-import { join as join15 } from "path";
+import { readdirSync, readFileSync as readFileSync9, statSync } from "fs";
+import { join as join14 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
@@ -3262,7 +2982,7 @@ async function maybeReportTokenUsage(args) {
   const next = { files, lastCheckedAt: nowMs };
   let dirEntries;
   try {
-    dirEntries = readdirSync2(dir);
+    dirEntries = readdirSync(dir);
   } catch {
     state3.set(codeName, next);
     return;
@@ -3273,7 +2993,7 @@ async function maybeReportTokenUsage(args) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
     if (!sessionId) continue;
-    const path = join15(dir, name);
+    const path = join14(dir, name);
     let st;
     try {
       st = statSync(path);
@@ -3289,7 +3009,7 @@ async function maybeReportTokenUsage(args) {
     }
     let content;
     try {
-      content = readFileSync10(path, "utf-8");
+      content = readFileSync9(path, "utf-8");
     } catch (err) {
       log2(`[token-usage] read failed for '${codeName}/${name}': ${err.message}`);
       continue;
@@ -3370,8 +3090,8 @@ async function maybeReportTokenUsage(args) {
 }
 
 // src/lib/workflow-run-reconciler.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
-import { join as join16 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import { join as join15 } from "path";
 var MIN_CHECK_INTERVAL_MS3 = 5 * 6e4;
 var SETTLE_MS = 3e4;
 var TRANSCRIPT_MTIME_WINDOW_MS2 = 2 * 24 * 60 * 60 * 1e3;
@@ -3385,12 +3105,12 @@ function collectJsonlRecursive(dir, minMtimeMs, out, depth) {
   if (depth > MAX_SUBAGENT_DEPTH) return;
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync2(dir);
   } catch {
     return;
   }
   for (const name of entries) {
-    const p = join16(dir, name);
+    const p = join15(dir, name);
     let st;
     try {
       st = statSync2(p);
@@ -3408,12 +3128,12 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
   const out = [];
   let entries;
   try {
-    entries = readdirSync3(transcriptDir);
+    entries = readdirSync2(transcriptDir);
   } catch {
     return out;
   }
   for (const name of entries) {
-    const path = join16(transcriptDir, name);
+    const path = join15(transcriptDir, name);
     let st;
     try {
       st = statSync2(path);
@@ -3425,7 +3145,7 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
       continue;
     }
     if (st.isDirectory()) {
-      collectJsonlRecursive(join16(path, "subagents"), minMtimeMs, out, 0);
+      collectJsonlRecursive(join15(path, "subagents"), minMtimeMs, out, 0);
     }
   }
   return out;
@@ -3470,7 +3190,7 @@ async function maybeReconcileWorkflowRunTokens(args) {
   const contents = [];
   for (const path of files) {
     try {
-      contents.push(readFileSync11(path, "utf-8"));
+      contents.push(readFileSync10(path, "utf-8"));
     } catch {
     }
   }
@@ -3515,8 +3235,8 @@ async function maybeReconcileWorkflowRunTokens(args) {
 }
 
 // src/lib/conversation-evaluator.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
-import { join as join17 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
+import { join as join16 } from "path";
 var MIN_CHECK_INTERVAL_MS4 = 5 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS3 = 7 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS = 5 * 6e4;
@@ -3947,12 +3667,12 @@ function readRecentTurns(dir, nowMs) {
   const visit = (d) => {
     let entries;
     try {
-      entries = readdirSync4(d, { withFileTypes: true });
+      entries = readdirSync3(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = join17(d, ent.name);
+      const full = join16(d, ent.name);
       if (ent.isDirectory()) {
         visit(full);
         continue;
@@ -3967,7 +3687,7 @@ function readRecentTurns(dir, nowMs) {
       if (nowMs - mtimeMs > TRANSCRIPT_MTIME_WINDOW_MS3) continue;
       let content;
       try {
-        content = readFileSync12(full, "utf8");
+        content = readFileSync11(full, "utf8");
       } catch {
         continue;
       }
@@ -4257,23 +3977,23 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 }
 
 // src/lib/tool-call-audit.ts
-import { homedir as homedir12 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join21 } from "path";
 
 // src/lib/agent-logging-mode.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join17 } from "path";
 var LOGGING_MODES = ["hash-only", "redacted", "full-local"];
 function charterPath(codeName, homeDir) {
-  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir9());
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir8());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join18(home, ".augmented", key, "provision", "CHARTER.md");
+  return join17(home, ".augmented", key, "provision", "CHARTER.md");
 }
 function readAgentLoggingMode(codeName, homeDir) {
   let raw;
   try {
-    raw = readFileSync13(charterPath(codeName, homeDir), "utf-8");
+    raw = readFileSync12(charterPath(codeName, homeDir), "utf-8");
   } catch {
     return { mode: null, reason: "no-charter" };
   }
@@ -4297,15 +4017,15 @@ function loggingModeWithholdsTargets(reading) {
 
 // src/lib/tool-call-path-salt.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync14, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname7, join as join19 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync13, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname6, join as join18 } from "path";
 var SALT_BYTES = 32;
 var SALT_RE = /^[0-9a-f]{64}$/;
 function pathSaltPath(codeName, homeDir) {
-  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir10());
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir9());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join19(home, ".augmented", key, "tool-call-path-salt");
+  return join18(home, ".augmented", key, "tool-call-path-salt");
 }
 function readToolCallPathSalt(codeName, homeDir) {
   let file;
@@ -4315,8 +4035,8 @@ function readToolCallPathSalt(codeName, homeDir) {
     return null;
   }
   try {
-    if (existsSync4(file)) {
-      const existing = readFileSync14(file, "utf-8").trim();
+    if (existsSync3(file)) {
+      const existing = readFileSync13(file, "utf-8").trim();
       if (SALT_RE.test(existing)) return existing;
     }
   } catch {
@@ -4324,7 +4044,7 @@ function readToolCallPathSalt(codeName, homeDir) {
   const salt = randomBytes(SALT_BYTES).toString("hex");
   const tmp = `${file}.tmp.${process.pid}`;
   try {
-    mkdirSync5(dirname7(file), { recursive: true, mode: 448 });
+    mkdirSync5(dirname6(file), { recursive: true, mode: 448 });
     writeFileSync7(tmp, `${salt}
 `, { encoding: "utf-8", mode: 384 });
     renameSync4(tmp, file);
@@ -4342,8 +4062,8 @@ function readToolCallPathSalt(codeName, homeDir) {
 import { statSync as statSync4 } from "fs";
 
 // src/lib/tool-call-extractor.ts
-import { closeSync, fstatSync, openSync, readFileSync as readFileSync15, readSync, readdirSync as readdirSync5 } from "fs";
-import { basename as basename2, join as join20, relative as relative2 } from "path";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync14, readSync, readdirSync as readdirSync4 } from "fs";
+import { basename as basename2, join as join19, relative } from "path";
 import { StringDecoder } from "string_decoder";
 
 // src/lib/tool-call-redaction.ts
@@ -4472,28 +4192,28 @@ function redactToolTargetInner(toolName, input, ctx) {
 var EXTRACTOR_VERSION = "e1";
 function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
   const files = [];
-  const mainAbs = join20(transcriptDir, `${sessionId}.jsonl`);
+  const mainAbs = join19(transcriptDir, `${sessionId}.jsonl`);
   files.push({
     absPath: mainAbs,
-    relPath: relative2(projectsRoot, mainAbs),
+    relPath: relative(projectsRoot, mainAbs),
     ref: "main",
     isSubagent: false,
     subagentId: null
   });
-  const subDir = join20(transcriptDir, sessionId, "subagents");
+  const subDir = join19(transcriptDir, sessionId, "subagents");
   let entries;
   try {
-    entries = readdirSync5(subDir);
+    entries = readdirSync4(subDir);
   } catch {
     return files;
   }
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const abs = join20(subDir, name);
+    const abs = join19(subDir, name);
     const stem = basename2(name, ".jsonl");
     files.push({
       absPath: abs,
-      relPath: relative2(projectsRoot, abs),
+      relPath: relative(projectsRoot, abs),
       ref: `subagent:${stem}`,
       isSubagent: true,
       subagentId: stem.startsWith("agent-") ? stem.slice("agent-".length) : stem
@@ -4687,9 +4407,9 @@ function extractTranscriptWindow(file, opts, from) {
 }
 
 // src/lib/tool-call-cursor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync16 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join21 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join20 } from "path";
 var COVERAGE_DISPOSITIONS = [
   "ok",
   "not_entitled",
@@ -4742,15 +4462,15 @@ function parseCursorKey(key) {
   return { sessionId: sessionId.length > 0 ? sessionId : null, transcriptRef: key.slice(i + 1) };
 }
 function cursorStatePath(codeName, homeDir) {
-  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir11());
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir10());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join21(home, ".augmented", key, "tool-call-cursors.json");
+  return join20(home, ".augmented", key, "tool-call-cursors.json");
 }
 function loadCursors(path) {
   const out = /* @__PURE__ */ new Map();
-  if (!existsSync5(path)) return out;
+  if (!existsSync4(path)) return out;
   try {
-    const parsed = JSON.parse(readFileSync16(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
     if (!parsed || parsed.version !== 1 || typeof parsed.files !== "object") return out;
     for (const [k, v] of Object.entries(parsed.files)) {
       if (!v || typeof v !== "object") continue;
@@ -5156,8 +4876,8 @@ async function maybeScanToolCalls(args) {
     if (!salt && !hashOnly) {
       log2(`[tool-call-audit] ${codeName}: no path-hash salt available \u2014 file targets withheld`);
     }
-    const home = args.homeDir ?? (process.env["HOME"]?.trim() || homedir12());
-    const projectsRoot = args.projectsRoot ?? join22(home, ".claude", "projects");
+    const home = args.homeDir ?? (process.env["HOME"]?.trim() || homedir11());
+    const projectsRoot = args.projectsRoot ?? join21(home, ".claude", "projects");
     const transcriptDir = args.transcriptDir ?? sessionTranscriptDir(getProjectDir(codeName));
     const current = peekCurrentSession(codeName);
     const sessionIds = current ? [current.sessionId] : [];
@@ -5186,11 +4906,11 @@ async function maybeScanToolCalls(args) {
 }
 
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync6, readFileSync as readFileSync17 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join22 } from "path";
 var MIN_CHECK_INTERVAL_MS7 = 6e4;
-var STATS_CACHE_PATH = join23(homedir13(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join22(homedir12(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state7 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -5233,12 +4953,12 @@ async function maybeReportActivityCache(args) {
   const nowMs = now.getTime();
   if (nowMs - state7.lastCheckedAt < MIN_CHECK_INTERVAL_MS7) return;
   state7.lastCheckedAt = nowMs;
-  if (!existsSync6(STATS_CACHE_PATH)) {
+  if (!existsSync5(STATS_CACHE_PATH)) {
     return;
   }
   let raw;
   try {
-    raw = readFileSync17(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync16(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
@@ -5474,8 +5194,111 @@ function computeChannelConfigHash(input) {
   ).digest("hex");
 }
 
+// src/lib/knowledge-cache.ts
+import { createHash as createHash9 } from "crypto";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync5,
+  renameSync as renameSync5,
+  rmSync as rmSync3,
+  statSync as statSync5,
+  utimesSync,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { join as join23 } from "path";
+var KNOWLEDGE_FETCH_CHUNK = 100;
+var CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var lastSweepAt = 0;
+function knowledgeHash(content) {
+  return createHash9("sha256").update(content, "utf8").digest("hex");
+}
+function cachePath(cacheDir, hash) {
+  return join23(cacheDir, hash);
+}
+function readCachedKnowledge(cacheDir, hash) {
+  const path = cachePath(cacheDir, hash);
+  try {
+    const content = readFileSync17(path, "utf-8");
+    try {
+      const now = /* @__PURE__ */ new Date();
+      utimesSync(path, now, now);
+    } catch {
+    }
+    return content;
+  } catch {
+    return null;
+  }
+}
+function writeCachedKnowledge(cacheDir, hash, content) {
+  if (knowledgeHash(content) !== hash) return false;
+  try {
+    mkdirSync6(cacheDir, { recursive: true });
+    const tmp = `${cachePath(cacheDir, hash)}.tmp-${process.pid}`;
+    writeFileSync8(tmp, content, "utf-8");
+    renameSync5(tmp, cachePath(cacheDir, hash));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sweepKnowledgeCache(cacheDir, now = Date.now()) {
+  if (now - lastSweepAt < SWEEP_INTERVAL_MS) return;
+  lastSweepAt = now;
+  try {
+    if (!existsSync6(cacheDir)) return;
+    for (const name of readdirSync5(cacheDir)) {
+      const path = join23(cacheDir, name);
+      try {
+        if (now - statSync5(path).mtimeMs > CACHE_TTL_MS) rmSync3(path, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function resolveKnowledgeFromManifest(args) {
+  const { manifest, cacheDir, delivery, fetchContents, log: log2 } = args;
+  const meta = (e) => ({ title: e.title, slug: e.slug, scope: e.scope });
+  if (delivery === "search") {
+    sweepKnowledgeCache(cacheDir);
+    return manifest.map((e) => ({ ...meta(e), content: null }));
+  }
+  const bodies = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const entry of manifest) {
+    if (!entry.hash || bodies.has(entry.hash)) continue;
+    const cached = readCachedKnowledge(cacheDir, entry.hash);
+    if (cached !== null) bodies.set(entry.hash, cached);
+    else if (!missing.includes(entry.hash)) missing.push(entry.hash);
+  }
+  if (missing.length > 0) {
+    for (let i = 0; i < missing.length; i += KNOWLEDGE_FETCH_CHUNK) {
+      const chunk2 = missing.slice(i, i + KNOWLEDGE_FETCH_CHUNK);
+      try {
+        for (const { hash, content } of await fetchContents(chunk2)) {
+          if (!writeCachedKnowledge(cacheDir, hash, content)) {
+            log2?.(`[knowledge] hash mismatch for ${hash} \u2014 dropping this poll`);
+            continue;
+          }
+          bodies.set(hash, content);
+        }
+      } catch (err) {
+        log2?.(`[knowledge] fetch failed for ${chunk2.length} entries: ${err.message}`);
+      }
+    }
+  }
+  sweepKnowledgeCache(cacheDir);
+  return manifest.map((e) => ({
+    ...meta(e),
+    content: (e.hash ? bodies.get(e.hash) : void 0) ?? null
+  }));
+}
+
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
 import { join as join24 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
@@ -5500,7 +5323,7 @@ function saveChannelHashCache(source, configDir) {
   const obj = {};
   for (const [key, value] of source) obj[key] = value;
   try {
-    writeFileSync8(path, JSON.stringify(obj, null, 2));
+    writeFileSync9(path, JSON.stringify(obj, null, 2));
   } catch {
   }
 }
@@ -6147,14 +5970,14 @@ import { join as join27 } from "path";
 function integrationSkillHashKey(agentId, skillId) {
   return `plugin-skill:${agentId}:${skillId}`;
 }
-function shouldWriteIntegrationSkill(cache3, agentId, skillId, contentHash) {
-  return cache3.get(integrationSkillHashKey(agentId, skillId)) !== contentHash;
+function shouldWriteIntegrationSkill(cache2, agentId, skillId, contentHash) {
+  return cache2.get(integrationSkillHashKey(agentId, skillId)) !== contentHash;
 }
-function rememberIntegrationSkill(cache3, agentId, skillId, contentHash) {
-  cache3.set(integrationSkillHashKey(agentId, skillId), contentHash);
+function rememberIntegrationSkill(cache2, agentId, skillId, contentHash) {
+  cache2.set(integrationSkillHashKey(agentId, skillId), contentHash);
 }
-function forgetIntegrationSkill(cache3, agentId, skillId) {
-  cache3.delete(integrationSkillHashKey(agentId, skillId));
+function forgetIntegrationSkill(cache2, agentId, skillId) {
+  cache2.delete(integrationSkillHashKey(agentId, skillId));
 }
 function removeIntegrationSkillFolder(opts) {
   forgetIntegrationSkill(opts.cache, opts.agentId, opts.entry);
@@ -6164,8 +5987,8 @@ function removeIntegrationSkillFolder(opts) {
 }
 
 // src/lib/manager/managed-skill-manifest.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join28 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync21, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname7, join as join28 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
   return join28(agentRootDir, "managed-skills.json");
@@ -6182,12 +6005,12 @@ function readManagedSkillManifest(path) {
 }
 function writeManagedSkillManifest(path, ids) {
   try {
-    mkdirSync6(dirname8(path), { recursive: true });
+    mkdirSync7(dirname7(path), { recursive: true });
     const body = {
       version: MANIFEST_VERSION,
       globalSkillIds: [...ids].sort()
     };
-    writeFileSync9(path, JSON.stringify(body, null, 2));
+    writeFileSync10(path, JSON.stringify(body, null, 2));
   } catch {
   }
 }
@@ -6299,9 +6122,9 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync11, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync11, rmSync as rmSync4 } from "fs";
 import { join as join29 } from "path";
-import { homedir as homedir14 } from "os";
+import { homedir as homedir13 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -6313,12 +6136,12 @@ 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 = join29(homedir14(), ".claude");
+    const claudeDir = join29(homedir13(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
       const p = join29(claudeDir, filename);
       if (existsSync11(p)) {
         try {
-          rmSync3(p, { force: true });
+          rmSync4(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
         } catch {
         }
@@ -6696,7 +6519,7 @@ function formatBoardForPrompt(items, template) {
 }
 
 // src/lib/manager/kanban/nudge-state-cache.ts
-import { existsSync as existsSync13, readFileSync as readFileSync23, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync23, writeFileSync as writeFileSync11 } from "fs";
 import { join as join31 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
@@ -6740,13 +6563,13 @@ function saveKanbanNudgeState(source, configDir) {
   const agents = {};
   for (const [codeName, state9] of source) agents[codeName] = state9;
   try {
-    writeFileSync10(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
+    writeFileSync11(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
   } catch {
   }
 }
 
 // src/lib/manager/kanban/notify.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 async function enqueueKanbanNotice(opts) {
   try {
     const res = await api.post(
@@ -6761,7 +6584,7 @@ async function enqueueKanbanNotice(opts) {
     return res.ok === true;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash9("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice enqueue failed for agent_id=${opts.agentId} error_id=${errId}`);
     return false;
   }
@@ -6776,7 +6599,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 = createHash9("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice cancel failed for agent_id=${agentId} error_id=${errId}`);
     return null;
   }
@@ -7182,7 +7005,7 @@ function deriveScheduledTaskNotify(task) {
 }
 
 // src/lib/manager/scheduler/runs.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 async function startRun(opts) {
   try {
     const res = await api.post(
@@ -7197,7 +7020,7 @@ async function startRun(opts) {
     };
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash11("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 };
   }
@@ -7236,7 +7059,7 @@ async function finishRun(runId, outcome, options = {}) {
       return;
     } catch (err) {
       const errText = err instanceof Error ? err.message : String(err);
-      const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
+      const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
       const status = err instanceof ApiError ? err.status : 0;
       if (isRetryableFinishError(err) && attempt < maxRetries) {
         log(
@@ -7265,7 +7088,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 = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
     return [];
   }
@@ -7325,13 +7148,13 @@ function closeSessionRunForCode(codeName, outcome, reason) {
 }
 
 // src/lib/manager/scheduler/kanban-route.ts
-import { createHash as createHash12 } from "crypto";
-import { writeFileSync as writeFileSync11, renameSync as renameSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync24, unlinkSync as unlinkSync3 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join32, dirname as dirname9 } from "path";
+import { createHash as createHash13 } from "crypto";
+import { writeFileSync as writeFileSync12, renameSync as renameSync6, mkdirSync as mkdirSync8, readFileSync as readFileSync24, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join32, dirname as dirname8 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 async function enqueueScheduledTaskNotice(opts) {
   try {
     const res = await api.post(
@@ -7348,7 +7171,7 @@ async function enqueueScheduledTaskNotice(opts) {
     return res.ok === true;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
     log(
       `[scheduled-kanban] notice enqueue failed for agent_id=${opts.agentId} task_id=${opts.taskId} error_id=${errId}`
     );
@@ -7687,17 +7510,17 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join32(homedir15(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join32(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
-    writeFileSync11(tmp, JSON.stringify(marker), "utf8");
-    renameSync5(tmp, file);
+    writeFileSync12(tmp, JSON.stringify(marker), "utf8");
+    renameSync6(tmp, file);
   } catch (err) {
     log(`[scheduled-kanban] scheduled-turn marker write failed for '${codeName}': ${err.message}`);
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join32(homedir15(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join32(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
     const raw = JSON.parse(readFileSync24(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
@@ -7759,9 +7582,9 @@ async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt, dura
       return false;
     }
     try {
-      const doorbell = directChatDoorbellPath(agentId, homedir15());
-      mkdirSync7(dirname9(doorbell), { recursive: true });
-      writeFileSync11(doorbell, String(Date.now()));
+      const doorbell = directChatDoorbellPath(agentId, homedir14());
+      mkdirSync8(dirname8(doorbell), { recursive: true });
+      writeFileSync12(doorbell, String(Date.now()));
     } catch (err) {
       log(`[scheduled-kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
     }
@@ -7827,24 +7650,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" : createHash12("sha256").update(trimmed).digest("hex").slice(0, 12);
+        const outputHash = trimmed.length === 0 ? "empty" : createHash13("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 = createHash12("sha256").update(assertion.reason ?? "").digest("hex").slice(0, 12);
+      const reasonHash = createHash13("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" : createHash12("sha256").update(trimmed).digest("hex").slice(0, 12);
+      const outputHash = trimmed.length === 0 ? "empty" : createHash13("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 = createHash12("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
+        const notesHash = createHash13("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) {
@@ -7910,12 +7733,12 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 }
 
 // src/lib/manager/scheduler/execution.ts
-import { createHash as createHash13 } from "crypto";
-import { homedir as homedir16 } from "os";
+import { createHash as createHash14 } from "crypto";
+import { homedir as homedir15 } from "os";
 import { join as join34 } from "path";
 
 // src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync6 } from "fs";
 import { join as join33 } from "path";
 var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
 function probeRateLimit(args) {
@@ -7934,7 +7757,7 @@ function probeRateLimit(args) {
     if (!name.endsWith(".jsonl")) continue;
     const path = join33(dir, name);
     try {
-      const st = statSync5(path);
+      const st = statSync6(path);
       if (!st.isFile() || st.mtimeMs < startMs) continue;
     } catch {
       continue;
@@ -8003,7 +7826,7 @@ function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
 
 // src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join34(homedir16(), ".augmented", "manager-claude-pids.json");
+  return join34(homedir15(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -8023,10 +7846,10 @@ function unregisterClaudeSpawn(pid) {
 }
 async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData, durableScheduledNudge = false) {
   const codeName = agent.code_name;
-  const stableTasksHash = createHash13("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const boardHash = boardItems.length > 0 ? createHash13("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 = createHash14("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash14("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 = createHash13("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+  const modelsHash = createHash14("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) {
@@ -8073,7 +7896,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 }
 
 // src/lib/occupancy-gate.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, statSync as statSync6 } from "fs";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, statSync as statSync7 } from "fs";
 import { join as join35 } from "path";
 function rostersMeasuredZero(mode, attested, runtimeRunning) {
   return mode === "enforce" && attested && runtimeRunning;
@@ -8083,12 +7906,12 @@ var MAX_RECORD_ALIGN_BYTES = 8 * 1024 * 1024;
 var GATE_MAX_BUCKET_AGE_MS = 30 * 6e4;
 var MAX_BRACKET_DEFERRAL_MS = 25 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS4 = GATE_MAX_BUCKET_AGE_MS + DEFAULT_NEIGHBOURHOOD_MS + 6e4;
-var cache2 = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
 var brackets = /* @__PURE__ */ new Map();
 function readAlignedTail(path, tailBytes, maxAlignBytes) {
   let fd = null;
   try {
-    const size = statSync6(path).size;
+    const size = statSync7(path).size;
     if (size <= 0) return { content: "", complete: true, truncated: false };
     fd = openSync2(path, "r");
     let readStart = Math.max(0, size - tailBytes);
@@ -8218,7 +8041,7 @@ function collectQualifyingTurns(codeName, nowMs, opts = {}) {
   const tailBytes = opts.tailBytes ?? TAIL_BYTES;
   const maxAlignBytes = opts.maxAlignBytes ?? MAX_RECORD_ALIGN_BYTES;
   const sinceMs = nowMs - TRANSCRIPT_MTIME_WINDOW_MS4;
-  const agentCache = cache2.get(codeName) ?? /* @__PURE__ */ new Map();
+  const agentCache = cache.get(codeName) ?? /* @__PURE__ */ new Map();
   const nextCache = /* @__PURE__ */ new Map();
   const all = /* @__PURE__ */ new Set();
   const eventsByPath = /* @__PURE__ */ new Map();
@@ -8232,7 +8055,7 @@ function collectQualifyingTurns(codeName, nowMs, opts = {}) {
   for (const path of paths) {
     let st;
     try {
-      st = statSync6(path);
+      st = statSync7(path);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
@@ -8271,7 +8094,7 @@ function collectQualifyingTurns(codeName, nowMs, opts = {}) {
     }
     for (const t of turns) all.add(t);
   }
-  cache2.set(codeName, nextCache);
+  cache.set(codeName, nextCache);
   const { toolCallBrackets, openToolCalls } = foldToolCallBrackets(codeName, eventsByPath, nowMs);
   return {
     turns: [...all].sort((a, b) => a - b),
@@ -8338,7 +8161,7 @@ function qualifyBuckets(buckets, qualifying, mode, nowMs, neighbourhoodMs = DEFA
 }
 
 // src/lib/pane-occupancy-sampler.ts
-import { statSync as statSync7 } from "fs";
+import { statSync as statSync8 } from "fs";
 var SAMPLE_INTERVAL_MS = 1e4;
 var IDLE_GAP_MS = 12e4;
 var POST_IDLE_CREDIT_MS = 6e4;
@@ -8352,7 +8175,7 @@ function hasFreshPaneObservation(codeName, nowMs, maxAgeMs = OBSERVATION_FRESH_M
 }
 function paneMtimeMs(codeName) {
   try {
-    return statSync7(paneLogPath(codeName)).mtimeMs;
+    return statSync8(paneLogPath(codeName)).mtimeMs;
   } catch {
     return null;
   }
@@ -8544,7 +8367,7 @@ function stopPidPressureSampler() {
 }
 
 // src/lib/opencode-slack-ingest.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 
 // ../../packages/core/dist/channels/slack-rich-text.js
 var MAX_DEPTH = 12;
@@ -9551,7 +9374,7 @@ function startSlackIngest(config2) {
 // src/lib/opencode-slack-ingest.ts
 var ingests = /* @__PURE__ */ new Map();
 function fingerprint(params) {
-  return createHash14("sha256").update(
+  return createHash15("sha256").update(
     JSON.stringify({
       appToken: params.appToken,
       botToken: params.botToken,
@@ -9632,7 +9455,7 @@ function stopAllOpencodeSlackIngests(log2) {
 }
 
 // src/lib/manager/opencode-scheduler.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 var MAX_OPENCODE_SCHED_CONCURRENCY = 2;
 var opencodeSchedulerStates = /* @__PURE__ */ new Map();
 var inFlightOpencodeTasks = /* @__PURE__ */ new Set();
@@ -9646,7 +9469,7 @@ function shouldDeliver(task, reply) {
 }
 async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
   const codeName = agent.code_name;
-  const tasksHash = createHash15("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const tasksHash = createHash16("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 state10 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
@@ -9724,8 +9547,8 @@ async function fireOpencodeScheduledTask(agent, task) {
 }
 
 // src/lib/opencode-telegram-ingest.ts
-import { createHash as createHash16 } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync27, renameSync as renameSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync12 } from "fs";
+import { createHash as createHash17 } from "crypto";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync27, renameSync as renameSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "fs";
 import { randomUUID } from "crypto";
 import { join as join36 } from "path";
 
@@ -10260,7 +10083,7 @@ function anySignal(signals) {
 // src/lib/opencode-telegram-ingest.ts
 var ingests2 = /* @__PURE__ */ new Map();
 function fingerprint2(params) {
-  return createHash16("sha256").update(
+  return createHash17("sha256").update(
     JSON.stringify({
       botToken: params.botToken,
       allowedChats: [...params.allowedChats].sort(),
@@ -10302,8 +10125,8 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       if (!filePath || !dir) return;
       const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       try {
-        mkdirSync8(dir, { recursive: true, mode: 448 });
-        writeFileSync12(
+        mkdirSync9(dir, { recursive: true, mode: 448 });
+        writeFileSync13(
           tmpPath,
           JSON.stringify({
             offset,
@@ -10313,7 +10136,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
           }),
           { mode: 384 }
         );
-        renameSync6(tmpPath, filePath);
+        renameSync7(tmpPath, filePath);
       } catch (err) {
         log2(`[telegram-ingest:${codeName}] offset persist failed: ${err instanceof Error ? err.message : String(err)}`);
         try {
@@ -10554,12 +10377,12 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync8, readFileSync as readFileSync28, renameSync as renameSync7, rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir17 } from "os";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readdirSync as readdirSync8, readFileSync as readFileSync28, renameSync as renameSync8, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir16 } from "os";
 import { join as join37 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join37(homedir17(), ".augmented", "restart-flags");
+  return join37(homedir16(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
   return join37(restartFlagsDir(), `${codeName}.flag`);
@@ -10590,7 +10413,7 @@ function readRestartFlags() {
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
   if (existsSync16(path)) {
-    rmSync4(path, { force: true });
+    rmSync5(path, { force: true });
   }
 }
 
@@ -10689,8 +10512,8 @@ async function sendError(flag, opts, text) {
 }
 
 // src/lib/restart-context.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync29, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, unlinkSync as unlinkSync5 } from "fs";
-import { dirname as dirname10, join as join38 } from "path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, unlinkSync as unlinkSync5 } from "fs";
+import { dirname as dirname9, join as join38 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -10699,7 +10522,7 @@ var RECONSTRUCT_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS3 = 5 * 6e4;
 var DEFAULT_MAX_MARKERS_PER_AGENT = 25;
 function augmentedAgentDir(codeName) {
-  return dirname10(getProjectDir(codeName));
+  return dirname9(getProjectDir(codeName));
 }
 function slackPendingInboundDir(codeName) {
   return join38(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
@@ -10756,8 +10579,8 @@ function readStrandedMarker(path) {
   return null;
 }
 function writeHintFile(path, dir, hint) {
-  mkdirSync10(dir, { recursive: true, mode: 448 });
-  writeFileSync14(path, JSON.stringify(hint), { mode: 384 });
+  mkdirSync11(dir, { recursive: true, mode: 448 });
+  writeFileSync15(path, JSON.stringify(hint), { mode: 384 });
 }
 function pruneHintsExcept(codeName, freshFilenames) {
   const ctxDir = slackRestartContextDir(codeName);
@@ -12178,8 +12001,8 @@ var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var dayRolloverInboundHold = /* @__PURE__ */ new Map();
 var INBOUND_HOLD_EPISODE_GAP_MS = 12e4;
 async function channelInboundActivityAgeSecondsFor(codeName) {
-  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-XJZSVXMW.js");
-  const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-TDZDQXBU.js");
+  const newest = newestPendingInboundActivityMtimeMs(dirname10(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
 }
@@ -12278,7 +12101,7 @@ function performLazyDayRolloverReset(codeName, agentTimezone) {
 }
 function paneLogAgeSecondsFor(codeName) {
   try {
-    const mtimeMs = statSync8(paneLogPath(codeName)).mtimeMs;
+    const mtimeMs = statSync9(paneLogPath(codeName)).mtimeMs;
     return Math.max(0, Math.floor((Date.now() - mtimeMs) / 1e3));
   } catch (err) {
     if (err?.code === "ENOENT") return null;
@@ -12429,7 +12252,7 @@ var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
     const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
-    return createHash17("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    return createHash18("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
@@ -12826,7 +12649,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.715" : "dev";
+var agtCliVersion = true ? "0.28.717" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -12921,7 +12744,7 @@ async function ensureToolkitCli(toolkitSlug) {
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      brewBinDir = dirname11(brewPath);
+      brewBinDir = dirname10(brewPath);
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
@@ -13114,8 +12937,8 @@ async function reapSupersededRuntimeImages(imageUri, localTag) {
 }
 function runAsync(cmd, args, opts) {
   return new Promise((resolve2, 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;
@@ -13177,8 +13000,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     const missing = MANAGED_SETTINGS_KEYS.filter((key) => settings[key] !== true);
     if (missing.length === 0) return "ok";
     for (const key of missing) settings[key] = true;
-    mkdirSync11(dirname11(path), { recursive: true });
-    writeFileSync15(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync12(dirname10(path), { recursive: true });
+    writeFileSync16(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set ${missing.map((k) => `${k}:true`).join(", ")} in ${path} (ENG-5786 unblocks Claude Code channels; ENG-9223 pre-approves project MCP servers so a headless session never freezes on the trust prompt)`);
     return "ok";
@@ -13273,7 +13096,7 @@ async function ensureFrameworkBinary(frameworkId) {
       log(`Claude Code install failed: ${err.message}`);
       return;
     }
-    const brewBinDir = dirname11(brewPath);
+    const brewBinDir = dirname10(brewPath);
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
@@ -13333,7 +13156,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join39(homedir18(), ".augmented", ".last-self-update-applied");
+  return join39(homedir17(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -13384,7 +13207,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 = join39(homedir18(), ".augmented", ".last-update-check");
+    const markerPath = join39(homedir17(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -13791,7 +13614,7 @@ async function runClaudeRuntimeAuthProbe() {
   ];
   try {
     const { stdout, stderr } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-      cwd: homedir18(),
+      cwd: homedir17(),
       timeout: RUNTIME_AUTH_PROBE_TIMEOUT_MS,
       stdin: "ignore",
       env: childEnv,
@@ -13831,7 +13654,7 @@ async function runHostUsageCommand() {
       ""
     ];
     const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-      cwd: homedir18(),
+      cwd: homedir17(),
       timeout: HOST_USAGE_POLL_TIMEOUT_MS,
       stdin: "ignore",
       env: childEnv,
@@ -13878,13 +13701,13 @@ async function checkClaudeAuth() {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync17(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join39(homedir18(), ".augmented");
+  const dir = join39(homedir17(), ".augmented");
   try {
-    mkdirSync11(dir, { recursive: true });
+    mkdirSync12(dir, { recursive: true });
   } catch {
   }
   const p = join39(dir, ".eval-empty-mcp.json");
-  writeFileSync15(p, JSON.stringify({ mcpServers: {} }));
+  writeFileSync16(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -13909,7 +13732,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir18(),
+    cwd: homedir17(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -14280,7 +14103,7 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync11, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync16 } = await import("fs");
+  const { readdirSync: readdirSync11, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync17 } = await import("fs");
   const skillsDir = join39(configDir, codeName, "project", ".claude", "skills");
   const claudeMdPath = join39(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
@@ -14330,7 +14153,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync16(claudeMdPath, next, "utf-8");
+    writeFileSync17(claudeMdPath, next, "utf-8");
     log2(
       injectSkillList ? `Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)` : `Refreshed CLAUDE.md managed block for '${codeName}' (skill list suppressed by claude-md-skills-index=false; ${entries.length} skills on disk)`
     );
@@ -14353,7 +14176,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-Z4UOM4V6.js");
+      const { collectDiagnostics } = await import("../persistent-session-GB3D5OIA.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -14471,7 +14294,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-Z4UOM4V6.js");
+      const { collectDiagnostics } = await import("../persistent-session-GB3D5OIA.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor) : void 0;
       let tailscaleHostname;
@@ -14501,7 +14324,7 @@ async function pollCycleInner() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash17("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash18("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state8.agents.some(
@@ -14640,7 +14463,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-XJZSVXMW.js");
+      } = await import("../responsiveness-probe-TDZDQXBU.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -14750,7 +14573,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-XJZSVXMW.js");
+        } = await import("../responsiveness-probe-TDZDQXBU.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -14842,7 +14665,7 @@ async function pollCycleInner() {
                 const paneTail = readFileSync30(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join39(homedir18(), ".augmented", codeName);
+                  const wedgeHome = join39(homedir17(), ".augmented", codeName);
                   if (existsSync17(wedgeHome)) {
                     atomicWriteFileSync(
                       join39(wedgeHome, "watchdog-give-up.json"),
@@ -14906,7 +14729,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-JA437JIB.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-KUYVUOK5.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-CPY4UZI7.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -15248,7 +15071,7 @@ async function pollCycleInner() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join39(homedir18(), ".augmented", codeName);
+          const dir = join39(homedir17(), ".augmented", codeName);
           if (!existsSync17(dir)) return;
           atomicWriteFileSync(
             join39(dir, "watchdog-give-up.json"),
@@ -15663,8 +15486,28 @@ async function processAgent(agent, agentStates, managedToolkits) {
   let refreshData;
   try {
     refreshData = await api.post("/host/refresh", {
-      agent_id: agent.agent_id
+      agent_id: agent.agent_id,
+      // ENG-9585: ask for hashes instead of knowledge bodies. An API build that
+      // predates the manifest ignores this and answers with `knowledge` as
+      // before, which the resolution below handles without a version check.
+      knowledge_manifest: true
     });
+    if (refreshData.knowledge_manifest) {
+      const resolved = await resolveKnowledgeFromManifest({
+        manifest: refreshData.knowledge_manifest,
+        cacheDir: join39(config.configDir, "_knowledge"),
+        delivery: refreshData.agent?.knowledge_delivery ?? "both",
+        fetchContents: async (hashes) => {
+          const res = await api.post(
+            "/host/knowledge/contents",
+            { agent_id: agent.agent_id, hashes }
+          );
+          return res.contents ?? [];
+        },
+        log
+      });
+      refreshData.knowledge = resolved;
+    }
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
     const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
@@ -15765,7 +15608,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter, renderIntegrationsSection);
     const changedFiles = [];
-    mkdirSync11(agentDir, { recursive: true });
+    mkdirSync12(agentDir, { recursive: true });
     for (const artifact of artifacts) {
       const filePath = join39(agentDir, artifact.relativePath);
       let existingHash;
@@ -15843,11 +15686,11 @@ async function processAgent(agent, agentStates, managedToolkits) {
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
         const filePath = join39(agentDir, file.relativePath);
-        mkdirSync11(dirname11(filePath), { recursive: true });
+        mkdirSync12(dirname10(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync15(filePath, file.content);
+          writeFileSync16(filePath, file.content);
         }
       }
       try {
@@ -15856,7 +15699,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           for (const folder of readdirSync10(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync5(join39(provSkillsDir, folder), { recursive: true });
+                rmSync6(join39(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -15894,7 +15737,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync5(join39(provWorkflowsDir, file));
+              rmSync6(join39(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -16255,8 +16098,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join39(homedir18(), ".augmented", agent.code_name);
-        mkdirSync11(agentAugmentedDir, { recursive: true });
+        const agentAugmentedDir = join39(homedir17(), ".augmented", agent.code_name);
+        mkdirSync12(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
           at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16339,7 +16182,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash17("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash18("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const msteamsBehaviourRestrictive = isMsTeamsBehaviourRestrictive(behaviourSubset);
       const behaviourDecision = decideSenderPolicyRestart({
@@ -16395,7 +16238,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash17("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash18("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourRestrictive = isSlackBehaviourRestrictive(slackBehaviourSubset);
       const slackBehaviourDecision = decideSenderPolicyRestart({
@@ -16452,9 +16295,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join39(homedir18(), ".augmented", agent.code_name, "project");
-      mkdirSync11(agentProvisionDir, { recursive: true });
-      mkdirSync11(projectDir, { recursive: true });
+      const projectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
+      mkdirSync12(agentProvisionDir, { recursive: true });
+      mkdirSync12(projectDir, { recursive: true });
       const provisionMcpPath = join39(agentProvisionDir, ".mcp.json");
       const projectMcpPath = join39(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
@@ -16463,7 +16306,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join39(homedir18(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join39(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -16512,7 +16355,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const staleChannelsPath = join39(projectDir, ".mcp-channels.json");
       if (existsSync17(staleChannelsPath)) {
         try {
-          rmSync5(staleChannelsPath, { force: true });
+          rmSync6(staleChannelsPath, { force: true });
         } catch {
         }
       }
@@ -16599,7 +16442,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join39(homedir18(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
         let probeSet = integrations;
         try {
           const quarantined = await api.post("/host/agent-integrations/quarantined", { agent_id: agent.agent_id });
@@ -16645,7 +16488,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join39(homedir18(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join39(homedir17(), ".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}`);
@@ -16722,7 +16565,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join39(homedir18(), ".augmented", agent.code_name, "project");
+        const projectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
         const envIntPath = join39(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
@@ -16837,10 +16680,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
           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 = createHash17("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash18("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash17("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash18("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);
@@ -16855,7 +16698,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
-            const urlHash = createHash17("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash18("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.readMcpServers) {
@@ -16935,7 +16778,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
       if (missing.length > 0) {
         log(`Auto-provisioned ${missing.length} default schedule(s) for '${agent.code_name}': ${missing.map((s) => s.template_id).join(", ")}`);
       }
-      const freshData = await api.post("/host/refresh", { agent_id: agent.agent_id });
+      const freshData = await api.post("/host/refresh", {
+        agent_id: agent.agent_id,
+        knowledge_manifest: true
+      });
       tasks = freshData.scheduled_tasks ?? tasks;
     }
   } catch (err) {
@@ -16958,7 +16804,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash18 } = await import("crypto");
+      const { createHash: createHash19 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -16987,7 +16833,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash18("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash19("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           if (!shouldWriteIntegrationSkill(
             agentState.knownSkillHashes,
             agent.agent_id,
@@ -17010,14 +16856,14 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const { readdirSync: readdirSync11, rmSync: rmSync6 } = await import("fs");
-        const { homedir: homedir19 } = await import("os");
+        const { readdirSync: readdirSync11, rmSync: rmSync7 } = await import("fs");
+        const { homedir: homedir18 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join39(homedir19(), ".augmented", agent.code_name, "skills"),
+          join39(homedir18(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join39(homedir19(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join39(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
           join39(agentDir, ".claude", "skills")
@@ -17042,7 +16888,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             dirs: existingDirs,
             removeDir: (p) => {
               if (existsSync17(p)) {
-                rmSync6(p, { recursive: true, force: true });
+                rmSync7(p, { recursive: true, force: true });
               }
             }
           });
@@ -17061,7 +16907,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join39(homedir18(), ".augmented", agent.code_name)
+          join39(homedir17(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -17070,7 +16916,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const plan = planGlobalSkillSync(
           [...globalSkillsPayload ?? [], ...sharedSkillsPayload ?? []],
           prevIds,
-          (content) => createHash18("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash19("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`),
           { desiredResolved }
         );
@@ -17081,8 +16927,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join39(homedir18(), ".augmented", agent.code_name, "skills"),
-            join39(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join39(homedir17(), ".augmented", agent.code_name, "skills"),
+            join39(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
             join39(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
@@ -17090,7 +16936,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             for (const dir of globalSkillDirs) {
               const p = join39(dir, id);
               if (existsSync17(p) && existsSync17(join39(p, "SKILL.md"))) {
-                rmSync5(p, { recursive: true, force: true });
+                rmSync6(p, { recursive: true, force: true });
                 prunedAny = true;
               }
             }
@@ -17121,7 +16967,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash18("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash19("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({
@@ -17136,9 +16982,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
             } else {
-              const stderrHash = createHash18("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash19("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash18("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash19("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}]`
               );
@@ -17709,7 +17555,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
                 freshDoneIds.add(item.id);
               }
             } catch (err) {
-              const errId = createHash17("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
+              const errId = createHash18("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
               log(`Reap API error for item_id=${item.id} error_id=${errId}`);
             }
             if (reapAction === "dead_letter") {
@@ -17775,7 +17621,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join39(homedir18(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join39(homedir17(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const obContactRaw = refreshData.agent.manager_last_contacted_at;
       const obContact = typeof obContactRaw === "string" && obContactRaw ? obContactRaw : null;
@@ -18182,7 +18028,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:${createHash17("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash18("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(
@@ -18196,7 +18042,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash17("sha256")
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash17("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash18("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -18393,7 +18239,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash17("sha256")
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash17("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash18("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));
@@ -18708,7 +18554,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-Z4UOM4V6.js");
+        const { collectDiagnostics } = await import("../persistent-session-GB3D5OIA.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -18759,7 +18605,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-Z4UOM4V6.js");
+      const { collectDiagnostics } = await import("../persistent-session-GB3D5OIA.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -18867,7 +18713,7 @@ function ensureRealtimeKanbanStarted(agentStates) {
               );
             }
           }).catch((err) => {
-            const errId = createHash17("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
+            const errId = createHash18("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
             log(
               `[realtime] Work trigger enqueue threw for '${agent.codeName}' item_id=${item.id} error_id=${errId} \u2014 hybrid nudge will retry`
             );
@@ -19075,7 +18921,7 @@ async function processDirectChatMessageOpencode(agent, msg) {
         body
       });
       recordCursorAdvanceOutcome(
-        dirname11(paneLogPath(agent.codeName)),
+        dirname10(paneLogPath(agent.codeName)),
         "direct-chat-manager",
         "reply",
         verdict
@@ -19105,7 +18951,7 @@ async function processDirectChatMessageOpencode(agent, msg) {
     } catch (err) {
       if (!recorded) {
         recordCursorAdvanceOutcome(
-          dirname11(paneLogPath(agent.codeName)),
+          dirname10(paneLogPath(agent.codeName)),
           "direct-chat-manager",
           "reply",
           { outcome: "failed", error: err.message, expected: 1 }
@@ -19156,9 +19002,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, homedir18());
-        mkdirSync11(dirname11(doorbell), { recursive: true });
-        writeFileSync15(doorbell, String(Date.now()));
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir17());
+        mkdirSync12(dirname10(doorbell), { recursive: true });
+        writeFileSync16(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) {
@@ -19285,9 +19131,9 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   }
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
-    const doorbell = directChatDoorbellPath(agentId, homedir18());
-    mkdirSync11(dirname11(doorbell), { recursive: true });
-    writeFileSync15(doorbell, String(Date.now()));
+    const doorbell = directChatDoorbellPath(agentId, homedir17());
+    mkdirSync12(dirname10(doorbell), { recursive: true });
+    writeFileSync16(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -19391,7 +19237,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-GYS4MOPM.js");
+  } = await import("../claude-pair-runtime-KWBCSCZO.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));
@@ -19426,12 +19272,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;
         }
@@ -19646,10 +19492,10 @@ function saveMemoryManifest(agentId, configDir, codeName) {
   if (!manifest) return;
   try {
     const path = memoryManifestPath(configDir, codeName);
-    mkdirSync11(memoryRetirementDir(configDir, codeName), { recursive: true });
+    mkdirSync12(memoryRetirementDir(configDir, codeName), { recursive: true });
     const tmp = `${path}.tmp`;
-    writeFileSync15(tmp, JSON.stringify(manifest, null, 2));
-    renameSync8(tmp, path);
+    writeFileSync16(tmp, JSON.stringify(manifest, null, 2));
+    renameSync9(tmp, path);
   } catch {
   }
 }
@@ -19740,7 +19586,7 @@ function applyMemoryTombstones(opts) {
       continue;
     }
     try {
-      const actual = createHash17("sha256").update(readFileSync30(filePath)).digest("hex");
+      const actual = createHash18("sha256").update(readFileSync30(filePath)).digest("hex");
       if (actual !== entry.sha) {
         outcomes.kept_modified++;
         outcomes.unapplied.push({ name: tomb.name, reason: "kept_modified" });
@@ -19750,16 +19596,16 @@ function applyMemoryTombstones(opts) {
         continue;
       }
       const destDir = retiredMemoryDir(configDir, agent.code_name);
-      mkdirSync11(destDir, { recursive: true });
+      mkdirSync12(destDir, { recursive: true });
       const stamp = Date.now();
       let dest = join39(destDir, `${entry.file}.${stamp}.retired`);
       for (let n = 1; existsSync17(dest); n++) {
         dest = join39(destDir, `${entry.file}.${stamp}-${n}.retired`);
       }
-      renameSync8(filePath, dest);
+      renameSync9(filePath, dest);
       try {
         const now = Date.now() / 1e3;
-        utimesSync(dest, now, now);
+        utimesSync2(dest, now, now);
       } catch {
       }
       delete manifest[tomb.name];
@@ -19795,7 +19641,7 @@ function reapRetiredMemories(configDir, codeName, log2) {
       if (!file.endsWith(".retired")) continue;
       const path = join39(dir, file);
       try {
-        if (statSync8(path).mtimeMs < cutoff) {
+        if (statSync9(path).mtimeMs < cutoff) {
           unlinkSync6(path);
           reaped++;
         }
@@ -19841,7 +19687,7 @@ async function syncMemories(agent, configDir, log2) {
       if (!file.endsWith(".md")) continue;
       try {
         const raw = readFileSync30(join39(memoryDir, file), "utf-8");
-        const fileHash = createHash17("sha256").update(raw).digest("hex").slice(0, 16);
+        const fileHash = createHash18("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$/, ""));
@@ -19892,7 +19738,7 @@ async function syncMemories(agent, configDir, log2) {
 }
 async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
   const localFiles = existsSync17(memoryDir) ? readdirSync10(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash17("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localListHash = createHash18("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
   try {
@@ -19900,14 +19746,14 @@ async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
       agent_id: agent.agent_id
     });
     const tombstones = Array.isArray(dbMemories.tombstones) ? dbMemories.tombstones : null;
-    const responseHash = createHash17("sha256").update(JSON.stringify({ m: dbMemories.memories ?? [], t: tombstones })).digest("hex").slice(0, 16);
+    const responseHash = createHash18("sha256").update(JSON.stringify({ m: dbMemories.memories ?? [], t: tombstones })).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return { status: "skipped", tombstones, truncated: dbMemories.tombstones_truncated === true };
     }
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync11(memoryDir, { recursive: true });
+      mkdirSync12(memoryDir, { recursive: true });
       const manifest = loadMemoryManifest(agent.agent_id, configDir, agent.code_name);
       let written = 0;
       let overwritten = 0;
@@ -19926,7 +19772,7 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 ${mem.content}
 `;
         const record = () => {
-          const sha = createHash17("sha256").update(desired).digest("hex");
+          const sha = createHash18("sha256").update(desired).digest("hex");
           const prev = manifest[mem.name];
           if (prev?.file === fileName && prev.sha === sha) return false;
           manifest[mem.name] = { file: fileName, sha };
@@ -19944,10 +19790,10 @@ ${mem.content}
             if (manifestDirty) saveMemoryManifest(agent.agent_id, configDir, agent.code_name);
             continue;
           }
-          writeFileSync15(filePath, desired);
+          writeFileSync16(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync15(filePath, desired);
+          writeFileSync16(filePath, desired);
           written++;
         }
         if (record()) manifestDirty = true;
@@ -19955,7 +19801,7 @@ ${mem.content}
       }
       if (written > 0 || overwritten > 0) {
         const updatedFiles = readdirSync10(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash17("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        lastLocalFileHash.set(agent.agent_id, createHash18("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -19968,7 +19814,7 @@ ${mem.content}
 async function cleanupAgentFiles(codeName, agentDir) {
   if (existsSync17(agentDir)) {
     try {
-      rmSync5(agentDir, { recursive: true, force: true });
+      rmSync6(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
     } catch (err) {
       log(`Failed to remove provision dir for '${codeName}': ${err.message}`);
@@ -19990,8 +19836,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
     });
@@ -20264,7 +20110,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=${join39(homedir18(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join39(homedir17(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -20311,16 +20157,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({
@@ -20390,9 +20236,9 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join39(homedir18(), ".augmented", "_mcp");
-  mkdirSync11(targetDir, { recursive: true });
-  const moduleDir = dirname11(fileURLToPath(import.meta.url));
+  const targetDir = join39(homedir17(), ".augmented", "_mcp");
+  mkdirSync12(targetDir, { recursive: true });
+  const moduleDir = dirname10(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
@@ -20401,7 +20247,7 @@ function deployMcpAssets() {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname11(dir);
+    const parent = dirname10(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20415,7 +20261,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync17(p)) return null;
-      return createHash17("sha256").update(readFileSync30(p)).digest("hex");
+      return createHash18("sha256").update(readFileSync30(p)).digest("hex");
     } catch {
       return null;
     }
@@ -20515,7 +20361,7 @@ function deployMcpAssets() {
   }
   const localMcpPath = join39(targetDir, "index.js");
   try {
-    const agentsDir = join39(homedir18(), ".augmented", "agents");
+    const agentsDir = join39(homedir17(), ".augmented", "agents");
     if (existsSync17(agentsDir)) {
       for (const entry of readdirSync10(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -20529,7 +20375,7 @@ function deployMcpAssets() {
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync15(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync16(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }