@integrity-labs/agt-cli 0.28.714 → 0.28.716

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-FBYIO3Z6.js";
+} from "../chunk-OOYUWMTR.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -112,7 +115,7 @@ import {
   takeZombieDetection,
   toOpencodeModel,
   writeEgressAllowlist
-} from "../chunk-F6AZ6KPI.js";
+} from "../chunk-ILDRNSOB.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-FM63TWR3.js";
+} from "../chunk-LHYYO4NY.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 { readFileSync as readFileSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, existsSync as existsSync16, rmSync as rmSync5, readdirSync as readdirSync9, statSync as statSync8, unlinkSync as unlinkSync6, renameSync as renameSync8, utimesSync } 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 join38, 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,24 +1679,24 @@ 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;
-  const readFileSync31 = deps.readFileSync ?? nodeReadFileSync;
+  const existsSync17 = deps.existsSync ?? nodeExistsSync;
+  const readFileSync30 = deps.readFileSync ?? nodeReadFileSync;
   const mcpDir = deps.mcpDir ?? getSharedMcpDir();
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync31(mcpConfigPath, "utf-8"));
+    parsed = JSON.parse(readFileSync30(mcpConfigPath, "utf-8"));
   } catch {
     return [];
   }
@@ -1996,7 +1716,7 @@ function findMissingMcpBundles(mcpConfigPath, deps = {}) {
     if (seenPaths.has(resolvedBundlePath)) continue;
     let present;
     try {
-      present = existsSync18(bundlePath);
+      present = existsSync17(bundlePath);
     } catch {
       continue;
     }
@@ -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;
@@ -5475,18 +5195,18 @@ function computeChannelConfigHash(input) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { join as join23 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join24(configDir, CACHE_FILENAME);
+  return join23(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
-  if (!existsSync7(path)) return;
+  if (!existsSync6(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf-8"));
+    parsed = JSON.parse(readFileSync17(path, "utf-8"));
   } catch {
     return;
   }
@@ -5506,8 +5226,8 @@ function saveChannelHashCache(source, configDir) {
 }
 
 // src/lib/sender-policy-baseline.ts
-import { existsSync as existsSync8, readFileSync as readFileSync19 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync18 } from "fs";
+import { join as join24 } from "path";
 var BASELINE_FILENAME = "sender-policy-baseline.json";
 var SENDER_POLICY_BASELINE_VERSION = 1;
 var BASELINE_CONCERNS = ["senderPolicy", "slackBehaviour", "msteamsBehaviour"];
@@ -5519,14 +5239,14 @@ function createDeliveryBaselineMaps() {
   };
 }
 function getSenderPolicyBaselineFile(configDir) {
-  return join25(configDir, BASELINE_FILENAME);
+  return join24(configDir, BASELINE_FILENAME);
 }
 function loadSenderPolicyBaseline(target, configDir, log2) {
   const path = getSenderPolicyBaselineFile(configDir);
-  if (!existsSync8(path)) return;
+  if (!existsSync7(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf-8"));
+    parsed = JSON.parse(readFileSync18(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[sender-policy] discarding corrupt ${BASELINE_FILENAME} (${err.message}) - restrictive-policy agents will take one fail-closed restart`
@@ -5575,8 +5295,8 @@ function saveSenderPolicyBaseline(source, configDir, log2) {
 }
 
 // src/lib/stuck-streak-store.ts
-import { existsSync as existsSync9, readFileSync as readFileSync20 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync19 } from "fs";
+import { join as join25 } from "path";
 var STORE_FILENAME = "stuck-streaks.json";
 var STUCK_STREAK_STORE_VERSION = 1;
 var STUCK_STREAK_CONCERNS = ["channelSync", "realtimeRebind"];
@@ -5584,7 +5304,7 @@ function createStuckStreakMaps() {
   return { channelSync: /* @__PURE__ */ new Map(), realtimeRebind: /* @__PURE__ */ new Map() };
 }
 function getStuckStreakStoreFile(configDir) {
-  return join26(configDir, STORE_FILENAME);
+  return join25(configDir, STORE_FILENAME);
 }
 function isValidPersistedStreak(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -5623,10 +5343,10 @@ function buildStuckStreakPayload(source) {
 }
 function loadStuckStreaks(target, configDir, log2) {
   const path = getStuckStreakStoreFile(configDir);
-  if (!existsSync9(path)) return;
+  if (!existsSync8(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf-8"));
+    parsed = JSON.parse(readFileSync19(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[stuck-streaks] discarding corrupt ${STORE_FILENAME} (${err.message}) \u2014 stuck-streak ages restart from zero and one spurious "recovered" close may follow`
@@ -6143,37 +5863,37 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // src/lib/manager/integration-skill-cache.ts
-import { join as join27 } from "path";
+import { join as join26 } 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);
   for (const dir of opts.dirs) {
-    opts.removeDir(join27(dir, opts.entry));
+    opts.removeDir(join26(dir, opts.entry));
   }
 }
 
 // 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 existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join27 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join28(agentRootDir, "managed-skills.json");
+  return join27(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
-    if (!existsSync10(path)) return /* @__PURE__ */ new Set();
-    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    if (!existsSync9(path)) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(readFileSync20(path, "utf-8"));
     const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
     return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
   } catch {
@@ -6182,7 +5902,7 @@ function readManagedSkillManifest(path) {
 }
 function writeManagedSkillManifest(path, ids) {
   try {
-    mkdirSync6(dirname8(path), { recursive: true });
+    mkdirSync6(dirname7(path), { recursive: true });
     const body = {
       version: MANIFEST_VERSION,
       globalSkillIds: [...ids].sort()
@@ -6299,9 +6019,9 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync11, rmSync as rmSync3 } from "fs";
-import { join as join29 } from "path";
-import { homedir as homedir14 } from "os";
+import { existsSync as existsSync10, rmSync as rmSync3 } from "fs";
+import { join as join28 } from "path";
+import { homedir as homedir13 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -6313,10 +6033,10 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join29(homedir14(), ".claude");
+    const claudeDir = join28(homedir13(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join29(claudeDir, filename);
-      if (existsSync11(p)) {
+      const p = join28(claudeDir, filename);
+      if (existsSync10(p)) {
         try {
           rmSync3(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -6397,8 +6117,8 @@ function heartbeatRuntimeAuthFields(probeVerdict) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync22 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync21 } from "fs";
+import { join as join29 } from "path";
 var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
@@ -6550,12 +6270,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join30(process.cwd(), "skills", skillId, "SKILL.md"),
-      join30(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join29(process.cwd(), "skills", skillId, "SKILL.md"),
+      join29(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync12(candidate)) {
-        const content = readFileSync22(candidate, "utf-8");
+      if (existsSync11(candidate)) {
+        const content = readFileSync21(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -6696,19 +6416,19 @@ 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 { join as join31 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync22, writeFileSync as writeFileSync10 } from "fs";
+import { join as join30 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join31(configDir, CACHE_FILENAME2);
+  return join30(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
-  if (!existsSync13(path)) return;
+  if (!existsSync12(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync23(path, "utf-8"));
+    parsed = JSON.parse(readFileSync22(path, "utf-8"));
   } catch {
     return;
   }
@@ -7326,9 +7046,9 @@ 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 { writeFileSync as writeFileSync11, renameSync as renameSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync23, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join31, dirname as dirname8 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
 import { createHash as createHash11 } from "crypto";
@@ -7687,7 +7407,7 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join32(homedir15(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join31(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");
@@ -7697,9 +7417,9 @@ function stampScheduledTurnMarker(codeName, taskId, target) {
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join32(homedir15(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join31(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
-    const raw = JSON.parse(readFileSync24(file, "utf8"));
+    const raw = JSON.parse(readFileSync23(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
     unlinkSync3(file);
     log(`[scheduled-kanban] scheduled-turn marker cleared for '${codeName}' (task ${taskId} complete)`);
@@ -7759,8 +7479,8 @@ async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt, dura
       return false;
     }
     try {
-      const doorbell = directChatDoorbellPath(agentId, homedir15());
-      mkdirSync7(dirname9(doorbell), { recursive: true });
+      const doorbell = directChatDoorbellPath(agentId, homedir14());
+      mkdirSync7(dirname8(doorbell), { recursive: true });
       writeFileSync11(doorbell, String(Date.now()));
     } catch (err) {
       log(`[scheduled-kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
@@ -7911,12 +7631,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 { join as join34 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join33 } from "path";
 
 // src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { join as join33 } from "path";
+import { readFileSync as readFileSync24, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { join as join32 } from "path";
 var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
 function probeRateLimit(args) {
   const now = args.now ?? /* @__PURE__ */ new Date();
@@ -7925,14 +7645,14 @@ function probeRateLimit(args) {
   const dir = args.transcriptDir ?? sessionTranscriptDir(args.projectDir);
   let entries;
   try {
-    entries = readdirSync6(dir);
+    entries = readdirSync5(dir);
   } catch {
     return UNKNOWN_RATE_LIMIT;
   }
   let newest = UNKNOWN_RATE_LIMIT;
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const path = join33(dir, name);
+    const path = join32(dir, name);
     try {
       const st = statSync5(path);
       if (!st.isFile() || st.mtimeMs < startMs) continue;
@@ -7941,7 +7661,7 @@ function probeRateLimit(args) {
     }
     let content;
     try {
-      content = readFileSync25(path, "utf-8");
+      content = readFileSync24(path, "utf-8");
     } catch {
       continue;
     }
@@ -8003,7 +7723,7 @@ function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
 
 // src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join34(homedir16(), ".augmented", "manager-claude-pids.json");
+  return join33(homedir15(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -8073,8 +7793,8 @@ 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 { join as join35 } from "path";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync6, readSync as readSync2, statSync as statSync6 } from "fs";
+import { join as join34 } from "path";
 function rostersMeasuredZero(mode, attested, runtimeRunning) {
   return mode === "enforce" && attested && runtimeRunning;
 }
@@ -8083,7 +7803,7 @@ 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;
@@ -8158,26 +7878,26 @@ function candidateTranscriptPaths(dir) {
   const paths = [];
   let top;
   try {
-    top = readdirSync7(dir);
+    top = readdirSync6(dir);
   } catch {
     return { paths, complete: false };
   }
   let complete = true;
   for (const name of top) {
     if (name.endsWith(".jsonl")) {
-      paths.push(join35(dir, name));
+      paths.push(join34(dir, name));
       continue;
     }
-    const subDir = join35(dir, name, "subagents");
+    const subDir = join34(dir, name, "subagents");
     let subs;
     try {
-      subs = readdirSync7(subDir);
+      subs = readdirSync6(subDir);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
     }
     for (const sub of subs) {
-      if (sub.endsWith(".jsonl")) paths.push(join35(subDir, sub));
+      if (sub.endsWith(".jsonl")) paths.push(join34(subDir, sub));
     }
   }
   return { paths, complete };
@@ -8218,7 +7938,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();
@@ -8271,7 +7991,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),
@@ -8404,7 +8124,7 @@ function stopPaneOccupancySampler() {
 
 // src/lib/pid-pressure-sampler.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync25 } from "fs";
 var SAMPLE_INTERVAL_MS2 = 3e4;
 function warnFraction() {
   const raw = Number(process.env.AGT_PID_PRESSURE_WARN_FRACTION);
@@ -8417,7 +8137,7 @@ function configuredCeiling() {
 }
 function readTextReal(path) {
   try {
-    return readFileSync26(path, "utf-8");
+    return readFileSync25(path, "utf-8");
   } catch {
     return null;
   }
@@ -8426,7 +8146,7 @@ var cgroupDirCache = /* @__PURE__ */ new Map();
 var resolveRetryAfter = /* @__PURE__ */ new Map();
 var RESOLVE_RETRY_BACKOFF_MS = 5 * 6e4;
 function resolveCgroupDirReal(codeName, deps = {}) {
-  const exists = deps.exists ?? existsSync14;
+  const exists = deps.exists ?? existsSync13;
   const inspectId = deps.inspectId ?? inspectContainerId;
   const now = deps.now ?? Date.now;
   const cached = cgroupDirCache.get(codeName);
@@ -9725,9 +9445,9 @@ 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 { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync26, renameSync as renameSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync12 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join36 } from "path";
+import { join as join35 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -10275,7 +9995,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join36(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join35(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -10284,7 +10004,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
     load() {
       if (!filePath) return 0;
       try {
-        const parsed = JSON.parse(readFileSync27(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync26(filePath, "utf-8"));
         if (currentBotId != null && typeof parsed?.bot_id === "number" && parsed.bot_id !== currentBotId) {
           log2(`[telegram-ingest:${codeName}] offset cursor belongs to a different bot; ignoring (bot swap)`);
           return 0;
@@ -10317,7 +10037,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       } catch (err) {
         log2(`[telegram-ingest:${codeName}] offset persist failed: ${err instanceof Error ? err.message : String(err)}`);
         try {
-          if (existsSync15(tmpPath)) unlinkSync4(tmpPath);
+          if (existsSync14(tmpPath)) unlinkSync4(tmpPath);
         } catch {
         }
       }
@@ -10554,24 +10274,24 @@ 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 { join as join37 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync27, renameSync as renameSync7, rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir16 } from "os";
+import { join as join36 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join37(homedir17(), ".augmented", "restart-flags");
+  return join36(homedir16(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join37(restartFlagsDir(), `${codeName}.flag`);
+  return join36(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync16(dir)) return [];
+  if (!existsSync15(dir)) return [];
   const out = [];
-  for (const entry of readdirSync8(dir)) {
+  for (const entry of readdirSync7(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync28(join37(dir, entry), "utf8");
+      const raw = readFileSync27(join36(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -10589,7 +10309,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync16(path)) {
+  if (existsSync15(path)) {
     rmSync4(path, { force: true });
   }
 }
@@ -10689,8 +10409,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 readdirSync8, readFileSync as readFileSync28, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, unlinkSync as unlinkSync5 } from "fs";
+import { dirname as dirname9, join as join37 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -10699,13 +10419,13 @@ 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);
+  return join37(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
 }
 function slackRestartContextDir(codeName) {
-  return join38(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
+  return join37(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
 }
 function sanitizeTopic(raw) {
   const cleaned = raw.replace(/\s+/g, " ").trim().replace(/[<>]/g, " ").replace(/\s+/g, " ").trim();
@@ -10740,14 +10460,14 @@ function computeRestartContextHints(markers, allTurns, nowMs, reconstruct = reco
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync9(dir);
+    return readdirSync8(dir);
   } catch {
     return [];
   }
 }
 function readStrandedMarker(path) {
   try {
-    const parsed = JSON.parse(readFileSync29(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync28(path, "utf-8"));
     if (typeof parsed.channel === "string" && typeof parsed.thread_ts === "string") {
       return { channel: parsed.channel, thread_ts: parsed.thread_ts };
     }
@@ -10765,7 +10485,7 @@ function pruneHintsExcept(codeName, freshFilenames) {
     if (!filename.endsWith(".json")) continue;
     if (freshFilenames.has(filename)) continue;
     try {
-      unlinkSync5(join38(ctxDir, filename));
+      unlinkSync5(join37(ctxDir, filename));
     } catch {
     }
   }
@@ -10786,7 +10506,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       }
       const markers = [];
       for (const filename of markerFilenames.slice(0, cap)) {
-        const parsed = readStrandedMarker(join38(markerDir, filename));
+        const parsed = readStrandedMarker(join37(markerDir, filename));
         if (parsed) markers.push({ filename, channel: parsed.channel, thread_ts: parsed.thread_ts });
       }
       if (markers.length === 0) {
@@ -10800,7 +10520,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       const freshFilenames = /* @__PURE__ */ new Set();
       for (const { filename, hint } of hints) {
         try {
-          writeHintFile(join38(ctxDir, filename), ctxDir, hint);
+          writeHintFile(join37(ctxDir, filename), ctxDir, hint);
           freshFilenames.add(filename);
         } catch (err) {
           log2(`[restart-context] ${codeName}: hint write failed for ${filename}: ${err.message}`);
@@ -12178,8 +11898,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-QDNULLSM.js");
-  const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-A5335ORT.js");
+  const newest = newestPendingInboundActivityMtimeMs(dirname10(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
 }
@@ -12428,7 +12148,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync29(join38(projectDir, ".mcp.json"), "utf-8");
     return createHash17("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -12436,7 +12156,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync29(join38(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -12454,7 +12174,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync29(join38(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -12580,7 +12300,7 @@ async function runAgentSessionToolBindProbes(agent, integrations, projectDir, op
   if (result && result.rebindCandidates.length > 0 && hostFlagStore().getBoolean("session-tool-rebind")) {
     let mcpJsonForRebind = null;
     try {
-      mcpJsonForRebind = JSON.parse(readFileSync30(join39(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync29(join38(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -12728,7 +12448,7 @@ function shouldInjectChannelSecrets(agentId) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync30(join39(projectDir, ".env.integrations"), "utf-8")
+      readFileSync29(join38(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -12826,7 +12546,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.714" : "dev";
+var agtCliVersion = true ? "0.28.716" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -12839,7 +12559,7 @@ function resolveBrewPath(execFileSync3) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync17(path)) return path;
+    if (existsSync16(path)) return path;
   }
   return null;
 }
@@ -12849,7 +12569,7 @@ function claudeBinaryInstalled(execFileSync3) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync17(path))) return true;
+  if (canonical.some((path) => existsSync16(path))) return true;
   try {
     execFileSync3("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -12921,7 +12641,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 +12834,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;
@@ -13159,8 +12879,8 @@ var MANAGED_SETTINGS_KEYS = ["channelsEnabled", "enableAllProjectMcpServers"];
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync17(path)) {
-      const raw = readFileSync30(path, "utf-8").trim();
+    if (existsSync16(path)) {
+      const raw = readFileSync29(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -13177,7 +12897,7 @@ 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 });
+    mkdirSync11(dirname10(path), { recursive: true });
     writeFileSync15(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)`);
@@ -13216,7 +12936,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync3("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join39(prefix, "bin");
+      const npmBin = join38(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -13273,11 +12993,11 @@ 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 ?? ""}`;
     }
-    if (existsSync17("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync16("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -13333,7 +13053,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join39(homedir18(), ".augmented", ".last-self-update-applied");
+  return join38(homedir17(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -13384,7 +13104,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 = join38(homedir17(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -13791,7 +13511,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 +13551,7 @@ async function runHostUsageCommand() {
       ""
     ];
     const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-      cwd: homedir18(),
+      cwd: homedir17(),
       timeout: HOST_USAGE_POLL_TIMEOUT_MS,
       stdin: "ignore",
       env: childEnv,
@@ -13877,13 +13597,13 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync17(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join39(homedir18(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync16(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join38(homedir17(), ".augmented");
   try {
     mkdirSync11(dir, { recursive: true });
   } catch {
   }
-  const p = join39(dir, ".eval-empty-mcp.json");
+  const p = join38(dir, ".eval-empty-mcp.json");
   writeFileSync15(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
@@ -13909,7 +13629,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir18(),
+    cwd: homedir17(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -13978,10 +13698,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join39(config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join38(config?.configDir ?? join38(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join38(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -14186,7 +13906,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join38(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -14202,12 +13922,12 @@ function claudeMdSizeFor(codeName) {
 }
 function forwardedToolsFor(codeName) {
   if (!config?.configDir) return null;
-  return readForwardedToolsReport(join39(config.configDir, codeName));
+  return readForwardedToolsReport(join38(config.configDir, codeName));
 }
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join38(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -14280,13 +14000,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync11, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync16 } = await import("fs");
-  const skillsDir = join39(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join39(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync10, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync16 } = await import("fs");
+  const skillsDir = join38(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join38(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
-  for (const dir of readdirSync11(skillsDir).sort()) {
-    const skillFile = join39(skillsDir, dir, "SKILL.md");
+  for (const dir of readdirSync10(skillsDir).sort()) {
+    const skillFile = join38(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -14353,7 +14073,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-XLYRD2CU.js");
+      const { collectDiagnostics } = await import("../persistent-session-DJSSEIR6.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -14471,7 +14191,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-XLYRD2CU.js");
+      const { collectDiagnostics } = await import("../persistent-session-DJSSEIR6.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor) : void 0;
       let tailscaleHostname;
@@ -14640,7 +14360,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-QDNULLSM.js");
+      } = await import("../responsiveness-probe-A5335ORT.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -14750,7 +14470,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-QDNULLSM.js");
+        } = await import("../responsiveness-probe-A5335ORT.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -14839,13 +14559,13 @@ async function pollCycleInner() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync30(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync29(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join39(homedir18(), ".augmented", codeName);
-                  if (existsSync17(wedgeHome)) {
+                  const wedgeHome = join38(homedir17(), ".augmented", codeName);
+                  if (existsSync16(wedgeHome)) {
                     atomicWriteFileSync(
-                      join39(wedgeHome, "watchdog-give-up.json"),
+                      join38(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -14906,7 +14626,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-JA437JIB.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-OAOR7OS4.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-KUYVUOK5.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -15161,7 +14881,7 @@ async function pollCycleInner() {
             `[drain-flush] FAILED for '${prev.codeName}': ${err.message} \u2014 proceeding to teardown; this session was NOT shipped (ENG-9491)`
           );
         }
-        const agentDir = join39(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join38(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -15248,10 +14968,10 @@ 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);
-          if (!existsSync17(dir)) return;
+          const dir = join38(homedir17(), ".augmented", codeName);
+          if (!existsSync16(dir)) return;
           atomicWriteFileSync(
-            join39(dir, "watchdog-give-up.json"),
+            join38(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         },
@@ -15270,9 +14990,9 @@ async function pollCycleInner() {
         // parser elsewhere can only reconstruct an hour (ENG-8901).
         signalUsageLimit: (codeName, resetsHint) => {
           const dir = getFramework("claude-code").getAgentDir(codeName);
-          if (!existsSync17(dir)) return;
+          if (!existsSync16(dir)) return;
           atomicWriteFileSync(
-            join39(dir, "watchdog-give-up.json"),
+            join38(dir, "watchdog-give-up.json"),
             JSON.stringify({
               gave_up_at: (/* @__PURE__ */ new Date()).toISOString(),
               reason: "usage_limit",
@@ -15534,7 +15254,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join39(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join38(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     forgetChannelSyncState(agent.agent_id);
     if (previousKnownStatus !== agent.status) {
@@ -15575,7 +15295,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync17(agentDir)
+        provisionDirExists: existsSync16(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -15709,7 +15429,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join39(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join38(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   agentRestartTimezoneInputs.set(agent.code_name, {
     agentTimezone: typeof refreshData.agent.timezone === "string" ? refreshData.agent.timezone : null,
@@ -15767,7 +15487,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const changedFiles = [];
     mkdirSync11(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join39(agentDir, artifact.relativePath);
+      const filePath = join38(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -15786,8 +15506,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join39(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync30(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join38(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync29(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -15805,7 +15525,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync30(filePath, "utf-8");
+          existingRaw = readFileSync29(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -15821,7 +15541,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       } else if (artifact.relativePath === "opencode.json") {
         let existingRaw = null;
         try {
-          existingRaw = readFileSync30(filePath, "utf-8");
+          existingRaw = readFileSync29(filePath, "utf-8");
         } catch {
         }
         const mergeResult = mergeOpencodeConfigArtifact(artifact.content, existingRaw);
@@ -15837,13 +15557,13 @@ async function processAgent(agent, agentStates, managedToolkits) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync17(join39(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync16(join38(agentDir, "CHARTER.md"));
       const verb = isFirst ? "Provisioning" : "Updating";
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        const filePath = join39(agentDir, file.relativePath);
-        mkdirSync11(dirname11(filePath), { recursive: true });
+        const filePath = join38(agentDir, file.relativePath);
+        mkdirSync11(dirname10(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
@@ -15851,12 +15571,12 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const provSkillsDir = join39(agentDir, ".claude", "skills");
-        if (existsSync17(provSkillsDir)) {
-          for (const folder of readdirSync10(provSkillsDir)) {
+        const provSkillsDir = join38(agentDir, ".claude", "skills");
+        if (existsSync16(provSkillsDir)) {
+          for (const folder of readdirSync9(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync5(join39(provSkillsDir, folder), { recursive: true });
+                rmSync5(join38(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -15869,7 +15589,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join39(agentDir, file));
+        const h = hashFile(join38(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -15887,14 +15607,14 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join39(agentDir, ".claude", "workflows");
-        if (existsSync17(provWorkflowsDir)) {
+        const provWorkflowsDir = join38(agentDir, ".claude", "workflows");
+        if (existsSync16(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
-          for (const file of readdirSync10(provWorkflowsDir)) {
+          for (const file of readdirSync9(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync5(join39(provWorkflowsDir, file));
+              rmSync5(join38(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -15973,10 +15693,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync17(agentDir)) {
+  if (written && existsSync16(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join39(agentDir, file));
+      const localHash = hashFile(join38(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -15987,7 +15707,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join39(agentDir, file));
+          localHashes[file] = hashFile(join38(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -16255,7 +15975,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join39(homedir18(), ".augmented", agent.code_name);
+        const agentAugmentedDir = join38(homedir17(), ".augmented", agent.code_name);
         mkdirSync11(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
@@ -16263,7 +15983,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join39(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join38(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -16452,24 +16172,24 @@ 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");
+      const projectDir = join38(homedir17(), ".augmented", agent.code_name, "project");
       mkdirSync11(agentProvisionDir, { recursive: true });
       mkdirSync11(projectDir, { recursive: true });
-      const provisionMcpPath = join39(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join39(projectDir, ".mcp.json");
+      const provisionMcpPath = join38(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join38(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync30(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync29(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join39(homedir18(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join38(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
         return typeof tz === "string" && tz.trim() !== "" ? tz.trim() : void 0;
       })();
-      if (existsSync17(localDirectChatChannel)) {
+      if (existsSync16(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -16489,7 +16209,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           // ~/.augmented/<codeName>/.current-turn-initiator.json. Note getAgentDir
           // returns the agent root (NOT the /provision subdir `agentDir` points at),
           // so it byte-matches the broker readers' path.
-          AGT_TURN_INITIATOR_FILE: join39(
+          AGT_TURN_INITIATOR_FILE: join38(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -16509,8 +16229,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join39(projectDir, ".mcp-channels.json");
-      if (existsSync17(staleChannelsPath)) {
+      const staleChannelsPath = join38(projectDir, ".mcp-channels.json");
+      if (existsSync16(staleChannelsPath)) {
         try {
           rmSync5(staleChannelsPath, { force: true });
         } catch {
@@ -16599,7 +16319,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join39(homedir18(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join38(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 +16365,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 = join38(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,11 +16442,11 @@ 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 envIntPath = join39(projectDir, ".env.integrations");
+        const projectDir = join38(homedir17(), ".augmented", agent.code_name, "project");
+        const envIntPath = join38(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync30(envIntPath, "utf-8");
+          preWriteEnv = readFileSync29(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -16745,9 +16465,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join39(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync30(envIntPath, "utf-8");
-            const mcpContent = readFileSync30(projectMcpPath, "utf-8");
+            const projectMcpPath = join38(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync29(envIntPath, "utf-8");
+            const mcpContent = readFileSync29(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -17010,23 +16730,23 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const { readdirSync: readdirSync11, rmSync: rmSync6 } = await import("fs");
-        const { homedir: homedir19 } = await import("os");
+        const { readdirSync: readdirSync10, rmSync: rmSync6 } = 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"),
+          join38(homedir18(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join39(homedir19(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join38(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")
+          join38(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync17(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync16(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
-            for (const entry of readdirSync11(dir)) {
+            for (const entry of readdirSync10(dir)) {
               if (entry.startsWith("plugin-") || entry.startsWith("integration-")) {
                 discoveredEntries.add(entry);
               }
@@ -17041,7 +16761,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             entry,
             dirs: existingDirs,
             removeDir: (p) => {
-              if (existsSync17(p)) {
+              if (existsSync16(p)) {
                 rmSync6(p, { recursive: true, force: true });
               }
             }
@@ -17061,7 +16781,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)
+          join38(homedir17(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -17081,15 +16801,15 @@ 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(agentDir, ".claude", "skills")
+            join38(homedir17(), ".augmented", agent.code_name, "skills"),
+            join38(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join38(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join39(dir, id);
-              if (existsSync17(p) && existsSync17(join39(p, "SKILL.md"))) {
+              const p = join38(dir, id);
+              if (existsSync16(p) && existsSync16(join38(p, "SKILL.md"))) {
                 rmSync5(p, { recursive: true, force: true });
                 prunedAny = true;
               }
@@ -17325,8 +17045,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join39(getProjectDir(agent.code_name), ".mcp.json");
-          mcpJsonParsed = JSON.parse(readFileSync30(mcpPath, "utf-8"));
+          const mcpPath = join38(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync29(mcpPath, "utf-8"));
         } catch {
         }
         reapMissingMcpSessions({
@@ -17757,10 +17477,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync17(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync16(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join39(agentDir, file));
+      const h = hashFile(join38(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -17775,7 +17495,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 = join38(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;
@@ -17877,7 +17597,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join39(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join38(getFramework("opencode").getAgentDir(codeName), "provision");
   const serveEnv = {
     AGT_HOST: requireHost(),
     AGT_API_KEY: getApiKey() ?? void 0,
@@ -17932,8 +17652,8 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     });
   }
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join39(projectDir, ".mcp.json");
-  const claudeMdPath = join39(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join38(projectDir, ".mcp.json");
+  const claudeMdPath = join38(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -18708,7 +18428,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-XLYRD2CU.js");
+        const { collectDiagnostics } = await import("../persistent-session-DJSSEIR6.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -18759,7 +18479,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-XLYRD2CU.js");
+      const { collectDiagnostics } = await import("../persistent-session-DJSSEIR6.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor)
@@ -19075,7 +18795,7 @@ async function processDirectChatMessageOpencode(agent, msg) {
         body
       });
       recordCursorAdvanceOutcome(
-        dirname11(paneLogPath(agent.codeName)),
+        dirname10(paneLogPath(agent.codeName)),
         "direct-chat-manager",
         "reply",
         verdict
@@ -19105,7 +18825,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,8 +18876,8 @@ 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 });
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir17());
+        mkdirSync11(dirname10(doorbell), { recursive: true });
         writeFileSync15(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;
@@ -19285,8 +19005,8 @@ ${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 });
+    const doorbell = directChatDoorbellPath(agentId, homedir17());
+    mkdirSync11(dirname10(doorbell), { recursive: true });
     writeFileSync15(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
@@ -19391,7 +19111,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-WW55WS2Q.js");
+  } = await import("../claude-pair-runtime-JK7GQU25.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 +19146,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;
         }
@@ -19616,17 +19336,17 @@ var lastDownloadHash = /* @__PURE__ */ new Map();
 var lastLocalFileHash = /* @__PURE__ */ new Map();
 var memoryManifests = /* @__PURE__ */ new Map();
 function memoryRetirementDir(configDir, codeName) {
-  return join39(configDir, "_memory-retirement", codeName);
+  return join38(configDir, "_memory-retirement", codeName);
 }
 function memoryManifestPath(configDir, codeName) {
-  return join39(memoryRetirementDir(configDir, codeName), "manifest.json");
+  return join38(memoryRetirementDir(configDir, codeName), "manifest.json");
 }
 function loadMemoryManifest(agentId, configDir, codeName) {
   const cached = memoryManifests.get(agentId);
   if (cached) return cached;
   let manifest = {};
   try {
-    const raw = readFileSync30(memoryManifestPath(configDir, codeName), "utf-8");
+    const raw = readFileSync29(memoryManifestPath(configDir, codeName), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       for (const [name, entry] of Object.entries(parsed)) {
@@ -19654,7 +19374,7 @@ function saveMemoryManifest(agentId, configDir, codeName) {
   }
 }
 function retiredMemoryDir(configDir, codeName) {
-  return join39(memoryRetirementDir(configDir, codeName), "retired");
+  return join38(memoryRetirementDir(configDir, codeName), "retired");
 }
 var RETIRED_MEMORY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var lastRetirementReport = /* @__PURE__ */ new Map();
@@ -19732,15 +19452,15 @@ function applyMemoryTombstones(opts) {
       log2(`[memory-retire] ${agent.code_name}: KEPT '${tomb.name}' \u2014 no write record, not ours to remove`);
       continue;
     }
-    const filePath = join39(memoryDir, entry.file);
-    if (!existsSync17(filePath)) {
+    const filePath = join38(memoryDir, entry.file);
+    if (!existsSync16(filePath)) {
       outcomes.already_gone++;
       delete manifest[tomb.name];
       manifestDirty = true;
       continue;
     }
     try {
-      const actual = createHash17("sha256").update(readFileSync30(filePath)).digest("hex");
+      const actual = createHash17("sha256").update(readFileSync29(filePath)).digest("hex");
       if (actual !== entry.sha) {
         outcomes.kept_modified++;
         outcomes.unapplied.push({ name: tomb.name, reason: "kept_modified" });
@@ -19752,9 +19472,9 @@ function applyMemoryTombstones(opts) {
       const destDir = retiredMemoryDir(configDir, agent.code_name);
       mkdirSync11(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`);
+      let dest = join38(destDir, `${entry.file}.${stamp}.retired`);
+      for (let n = 1; existsSync16(dest); n++) {
+        dest = join38(destDir, `${entry.file}.${stamp}-${n}.retired`);
       }
       renameSync8(filePath, dest);
       try {
@@ -19787,13 +19507,13 @@ function applyMemoryTombstones(opts) {
 }
 function reapRetiredMemories(configDir, codeName, log2) {
   const dir = retiredMemoryDir(configDir, codeName);
-  if (!existsSync17(dir)) return;
+  if (!existsSync16(dir)) return;
   const cutoff = Date.now() - RETIRED_MEMORY_TTL_MS;
   let reaped = 0;
   try {
-    for (const file of readdirSync10(dir)) {
+    for (const file of readdirSync9(dir)) {
       if (!file.endsWith(".retired")) continue;
-      const path = join39(dir, file);
+      const path = join38(dir, file);
       try {
         if (statSync8(path).mtimeMs < cutoff) {
           unlinkSync6(path);
@@ -19808,8 +19528,8 @@ function reapRetiredMemories(configDir, codeName, log2) {
   if (reaped > 0) log2(`[memory-retire] ${codeName}: reaped ${reaped} retired memory file(s) past TTL`);
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join39(configDir, agent.code_name, "project");
-  const memoryDir = join39(projectDir, "memory");
+  const projectDir = join38(configDir, agent.code_name, "project");
+  const memoryDir = join38(projectDir, "memory");
   const isFreshSync = pendingFreshMemorySync.has(agent.agent_id);
   if (isFreshSync) {
     log2(`[memory-sync] Fresh-sync requested for '${agent.code_name}' \u2014 pulling DB first`);
@@ -19833,14 +19553,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync17(memoryDir)) {
+  if (existsSync16(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
-    for (const file of readdirSync10(memoryDir)) {
+    for (const file of readdirSync9(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync30(join39(memoryDir, file), "utf-8");
+        const raw = readFileSync29(join38(memoryDir, file), "utf-8");
         const fileHash = createHash17("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -19865,7 +19585,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync30(join39(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync29(join38(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -19891,7 +19611,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 localFiles = existsSync16(memoryDir) ? readdirSync9(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash17("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -19916,7 +19636,7 @@ async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
         const fileName = `${slug}.md`;
-        const filePath = join39(memoryDir, fileName);
+        const filePath = join38(memoryDir, fileName);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -19933,10 +19653,10 @@ ${mem.content}
           return true;
         };
         let manifestDirty = false;
-        if (existsSync17(filePath)) {
+        if (existsSync16(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync30(filePath, "utf-8");
+            existing = readFileSync29(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) {
@@ -19954,7 +19674,7 @@ ${mem.content}
         if (manifestDirty) saveMemoryManifest(agent.agent_id, configDir, agent.code_name);
       }
       if (written > 0 || overwritten > 0) {
-        const updatedFiles = readdirSync10(memoryDir).filter((f) => f.endsWith(".md")).sort();
+        const updatedFiles = readdirSync9(memoryDir).filter((f) => f.endsWith(".md")).sort();
         lastLocalFileHash.set(agent.agent_id, createHash17("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
@@ -19966,7 +19686,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync17(agentDir)) {
+  if (existsSync16(agentDir)) {
     try {
       rmSync5(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -19990,8 +19710,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
     });
@@ -20236,8 +19956,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync17(stateFile)) {
-      const raw = readFileSync30(stateFile, "utf-8");
+    if (existsSync16(stateFile)) {
+      const raw = readFileSync29(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state8.agents = parsed.agents;
@@ -20264,7 +19984,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=${join38(homedir17(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -20293,7 +20013,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync30(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync29(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -20311,16 +20031,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,18 +20110,18 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join39(homedir18(), ".augmented", "_mcp");
+  const targetDir = join38(homedir17(), ".augmented", "_mcp");
   mkdirSync11(targetDir, { recursive: true });
-  const moduleDir = dirname11(fileURLToPath(import.meta.url));
+  const moduleDir = dirname10(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join39(dir, "dist", "mcp");
-    if (existsSync17(join39(candidate, "index.js"))) {
+    const candidate = join38(dir, "dist", "mcp");
+    if (existsSync16(join38(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname11(dir);
+    const parent = dirname10(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20414,8 +20134,8 @@ function deployMcpAssets() {
   const failedFiles = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync17(p)) return null;
-      return createHash17("sha256").update(readFileSync30(p)).digest("hex");
+      if (!existsSync16(p)) return null;
+      return createHash17("sha256").update(readFileSync29(p)).digest("hex");
     } catch {
       return null;
     }
@@ -20486,9 +20206,9 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join39(mcpSourceDir, file);
-    const dst = join39(targetDir, file);
-    if (!existsSync17(src)) continue;
+    const src = join38(mcpSourceDir, file);
+    const dst = join38(targetDir, file);
+    if (!existsSync16(src)) continue;
     attemptedFiles.push(file);
     const before = fileHash(dst);
     try {
@@ -20513,16 +20233,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join39(targetDir, "index.js");
+  const localMcpPath = join38(targetDir, "index.js");
   try {
-    const agentsDir = join39(homedir18(), ".augmented", "agents");
-    if (existsSync17(agentsDir)) {
-      for (const entry of readdirSync10(agentsDir, { withFileTypes: true })) {
+    const agentsDir = join38(homedir17(), ".augmented", "agents");
+    if (existsSync16(agentsDir)) {
+      for (const entry of readdirSync9(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join39(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join38(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync30(mcpJsonPath, "utf-8");
+            const raw = readFileSync29(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];