@integrity-labs/agt-cli 0.27.150-test.16 → 0.27.150-test.17

package/dist/lib/manager-worker.js

@@ -15,10 +15,11 @@ import {
   provisionAutoKanbanProgressHook,
   provisionIsolationHook,
   provisionOrientHook,
+  provisionSessionStateHook,
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-QHEAAPEG.js";
+} from "../chunk-L2JA4OHU.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -37,10 +38,13 @@ import {
   getSessionState,
   injectMessage,
   injectMessageWithStatus,
+  isAgentIdle,
   isAgentPromptReady,
   isSessionHealthy,
+  isStaleForToday,
   paneLogPath,
   parseEnvIntegrations,
+  peekCurrentSession,
   prepareForRespawn,
   probeMcpEnvSubstitution,
   readPaneLogTail,
@@ -49,16 +53,20 @@ import {
   rotateSessionForWedge,
   sanitizeMcpJson,
   sendToAgent,
+  sessionTranscriptDir,
   startPersistentSession,
   stopAllSessionsAndWait,
   stopPersistentSession,
+  subagentActivityAgeSeconds,
   takeWatchdogGiveUpCount,
-  takeZombieDetection
-} from "../chunk-7GKJZBTB.js";
+  takeZombieDetection,
+  transcriptActivityAgeSeconds
+} from "../chunk-HXMLMIR4.js";
 import {
   KANBAN_CHECK_COMMAND,
   MAX_AVATAR_ENV_URL_BYTES,
   SUPPRESS_SENTINEL,
+  StreamEncoder,
   appendDmFooter,
   attributeTranscriptUsageByRun,
   classifyActor,
@@ -83,13 +91,7 @@ import {
   resolveDmTarget,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "../chunk-WOOYOAPG.js";
-import {
-  isAgentIdle,
-  isStaleForToday,
-  peekCurrentSession,
-  sessionTranscriptDir
-} from "../chunk-354FAVQR.js";
+} from "../chunk-FZTGR2AQ.js";
 import {
   parsePsRows,
   reapOrphanChannelMcps
@@ -100,8 +102,8 @@ import { createHash as createHash3 } from "crypto";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, appendFileSync, mkdirSync as mkdirSync4, chmodSync, existsSync as existsSync5, rmSync as rmSync2, readdirSync as readdirSync4, statSync as statSync3, unlinkSync, copyFileSync } from "fs";
 import https from "https";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join8, dirname as dirname3 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join9, dirname as dirname3 } from "path";
+import { homedir as homedir5 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/mcp-config-drift.ts
@@ -1515,6 +1517,7 @@ function isUrgentUpgrade(opts) {
 }
 var RESTART_IDLE_THRESHOLD_SECONDS = 120;
 var RESTART_INBOUND_QUIET_SECONDS = 300;
+var RESTART_TRANSCRIPT_STALE_SECONDS = 60;
 var GATEABLE_RESTART_REASONS = /* @__PURE__ */ new Set([
   "model-change",
   "channel-set-change",
@@ -1533,9 +1536,11 @@ function decideRestartGate(opts) {
   }
   const paneThreshold = opts.idleThresholdSeconds ?? RESTART_IDLE_THRESHOLD_SECONDS;
   const inboundThreshold = opts.inboundQuietSeconds ?? RESTART_INBOUND_QUIET_SECONDS;
-  const paneBusy = opts.paneLogAgeSeconds !== null && opts.paneLogAgeSeconds < paneThreshold;
+  const transcriptThreshold = opts.transcriptStaleSeconds ?? RESTART_TRANSCRIPT_STALE_SECONDS;
+  const transcriptAge = opts.transcriptAgeSeconds ?? null;
+  const progressBusy = transcriptAge !== null ? transcriptAge < transcriptThreshold : opts.paneLogAgeSeconds !== null && opts.paneLogAgeSeconds < paneThreshold;
   const inboundBusy = opts.inboundAgeSeconds !== null && opts.inboundAgeSeconds < inboundThreshold;
-  if (paneBusy || inboundBusy) return "defer-idle";
+  if (progressBusy || inboundBusy) return "defer-idle";
   return "proceed";
 }
 
@@ -1682,9 +1687,146 @@ var DirectChatSpawnGate = class {
   }
 };
 
+// src/lib/artifact-stream.ts
+import { join as join2 } from "path";
+import { homedir } from "os";
+import { readdir, stat, readFile } from "fs/promises";
+var ARTEFACT_ENTRY_FILE = "index.html";
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var ArtifactStreamSession = class {
+  constructor(agentId, clientToken, deps, meta = {}) {
+    this.agentId = agentId;
+    this.clientToken = clientToken;
+    this.deps = deps;
+    this.meta = meta;
+    this.encoder = new StreamEncoder(deps.now ? { now: deps.now } : {});
+  }
+  encoder;
+  draftId = null;
+  creating = null;
+  /** The draft id once created, else null. */
+  get id() {
+    return this.draftId;
+  }
+  /**
+   * Create the draft on first use (idempotent via client_token — a manager
+   * restart returns the same draft). Concurrent callers share one in-flight
+   * request. Returns null on failure (best-effort; the next snapshot retries).
+   */
+  async ensureDraft() {
+    if (this.draftId) return this.draftId;
+    if (!this.creating) {
+      this.creating = this.deps.api.post("/host/artifacts/draft", {
+        agent_id: this.agentId,
+        client_token: this.clientToken,
+        kind: this.meta.kind ?? "other",
+        ...this.meta.title ? { title: this.meta.title } : {}
+      }).then((res) => {
+        this.draftId = res?.id ?? null;
+        return this.draftId;
+      }).catch((err) => {
+        this.deps.log?.(`[artifact-stream] draft create failed (${this.clientToken}): ${errMessage(err)}`);
+        return null;
+      }).finally(() => {
+        this.creating = null;
+      });
+    }
+    return this.creating;
+  }
+  /** Encode one snapshot and relay its frame(s). Best-effort, never throws. */
+  async pushSnapshot(content) {
+    const id = await this.ensureDraft();
+    if (!id) return;
+    const frames = this.encoder.encode(content);
+    for (const frame of frames) {
+      try {
+        await this.deps.api.post(`/host/artifacts/${encodeURIComponent(id)}/stream`, {
+          agent_id: this.agentId,
+          frame
+        });
+      } catch (err) {
+        this.deps.log?.(`[artifact-stream] frame ${frame.seq} failed (${id}): ${errMessage(err)}`);
+      }
+    }
+  }
+};
+var ArtifactStreamScanner = class {
+  constructor(agentId, artifactsDir, fsDeps, deps) {
+    this.agentId = agentId;
+    this.artifactsDir = artifactsDir;
+    this.fsDeps = fsDeps;
+    this.deps = deps;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  seenMtime = /* @__PURE__ */ new Map();
+  scanning = false;
+  /** One scan pass. Reads + streams every changed artefact. Never throws. */
+  async scanOnce() {
+    if (this.scanning) return;
+    this.scanning = true;
+    try {
+      let names;
+      try {
+        names = await this.fsDeps.listArtefactNames(this.artifactsDir);
+      } catch {
+        return;
+      }
+      for (const name of names) {
+        const file = join2(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;
+        let content;
+        try {
+          content = await this.fsDeps.readFile(file);
+        } catch (err) {
+          this.deps.log?.(`[artifact-stream] read failed (${name}): ${errMessage(err)}`);
+          continue;
+        }
+        this.seenMtime.set(name, mtime);
+        await this.sessionFor(name).pushSnapshot(content);
+      }
+      const live = new Set(names);
+      for (const key of this.seenMtime.keys()) if (!live.has(key)) this.seenMtime.delete(key);
+      for (const key of this.sessions.keys()) if (!live.has(key)) this.sessions.delete(key);
+    } finally {
+      this.scanning = false;
+    }
+  }
+  sessionFor(name) {
+    let session = this.sessions.get(name);
+    if (!session) {
+      session = new ArtifactStreamSession(this.agentId, name, this.deps, { title: name });
+      this.sessions.set(name, session);
+    }
+    return session;
+  }
+};
+function artifactsDirFor(codeName) {
+  return join2(homedir(), ".augmented", codeName, "artifacts");
+}
+var nodeArtifactFs = {
+  async listArtefactNames(artifactsDir) {
+    const entries = await readdir(artifactsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  },
+  async mtimeMs(filePath) {
+    try {
+      return (await stat(filePath)).mtimeMs;
+    } catch {
+      return null;
+    }
+  },
+  readFile(filePath) {
+    return readFile(filePath, "utf8");
+  }
+};
+
 // src/lib/usage-banner-monitor.ts
 var MIN_CHECK_INTERVAL_MS = 6e4;
-var PANE_TAIL_LINES_FOR_BANNER = 200;
+var PANE_TAIL_LINES_FOR_BANNER = 5e3;
 var state = /* @__PURE__ */ new Map();
 async function maybeReportUsageBanner(args) {
   const { api: api2, codeName, agentId, log: log2 } = args;
@@ -1739,7 +1881,7 @@ async function maybeReportUsageBanner(args) {
 
 // src/lib/token-usage-monitor.ts
 import { readdirSync, readFileSync as readFileSync4, statSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
@@ -1768,7 +1910,7 @@ async function maybeReportTokenUsage(args) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
     if (!sessionId) continue;
-    const path = join2(dir, name);
+    const path = join3(dir, name);
     let st;
     try {
       st = statSync(path);
@@ -1866,7 +2008,7 @@ async function maybeReportTokenUsage(args) {
 
 // src/lib/conversation-evaluator.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var MIN_CHECK_INTERVAL_MS3 = 5 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS2 = 3 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS = 5 * 6e4;
@@ -2103,7 +2245,7 @@ function readRecentTurns(dir, nowMs) {
   const turns = [];
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const full = join3(dir, name);
+    const full = join4(dir, name);
     let mtimeMs;
     try {
       mtimeMs = statSync2(full).mtimeMs;
@@ -2283,10 +2425,10 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 
 // src/lib/activity-cache-monitor.ts
 import { existsSync as existsSync2, readFileSync as readFileSync6 } from "fs";
-import { homedir } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
 var MIN_CHECK_INTERVAL_MS5 = 6e4;
-var STATS_CACHE_PATH = join4(homedir(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join5(homedir2(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state5 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -2782,9 +2924,9 @@ var GatewayClientPool = class extends EventEmitter {
 };
 
 // src/lib/claude-auth-detect.ts
-import { readFile, readdir } from "fs/promises";
-import { homedir as homedir2, platform } from "os";
-import { join as join5 } from "path";
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { homedir as homedir3, platform } from "os";
+import { join as join6 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
@@ -2799,17 +2941,17 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join5(homedir2(), ".claude", ".credentials.json"),
-    join5(homedir2(), ".claude", "credentials.json")
+    join6(homedir3(), ".claude", ".credentials.json"),
+    join6(homedir3(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
     try {
-      const entries = await readdir("/home", { withFileTypes: true });
+      const entries = await readdir2("/home", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        candidates.push(join5("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join5("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join6("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join6("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -2845,7 +2987,7 @@ async function readMacKeychain() {
 }
 async function readJsonSilently(path) {
   try {
-    const raw = await readFile(path, "utf-8");
+    const raw = await readFile2(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2902,10 +3044,10 @@ function normalize(value) {
 
 // src/lib/channel-hash-cache.ts
 import { existsSync as existsSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join6(configDir, CACHE_FILENAME);
+  return join7(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
@@ -3377,13 +3519,18 @@ function clearAgentState(agentId, codeName) {
 // src/lib/wedge-detection.ts
 var DEFAULTS = {
   inboundWaitSeconds: 120,
-  // ENG-6238: the hard cap is now an ABSOLUTE BACKSTOP, not the primary
-  // discriminator — a still-producing session (e.g. a runaway loop) is only
-  // reaped here. Raised 300→1200 because the soft path now reliably catches
-  // the frozen-turn wedge via the transcript signal, so the hard cap no longer
-  // needs to fire early (which is exactly what false-killed kylie's long
-  // legitimate turns, ENG-6238).
-  inboundHardWaitSeconds: 1200,
+  // ENG-6264: DISABLED by default (0). A session that's actively producing
+  // tokens is never force-respawned — a working agent must not be killed just
+  // because a message has been queued behind its turn, no matter how long.
+  // ENG-6238 made this an absolute backstop (1200s) to still catch a
+  // producing-but-never-draining runaway loop, but that re-introduced the exact
+  // failure we set out to kill: cutting off real work on a long turn. Runaway
+  // token burn is owned by the cost guardrail (ENG-5556); a producing-but-silent
+  // loop still trips the synthetic-probe alarm. So the backstop is now opt-in:
+  // set AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS to a positive value to re-enable it
+  // (floored at inboundWaitSeconds). 0 = the frozen/hung wedge (transcript
+  // static) is still caught by the soft path; only the *producing* path is spared.
+  inboundHardWaitSeconds: 0,
   paneStaleSeconds: 120,
   transcriptStaleSeconds: 60,
   minCycles: 3
@@ -3402,10 +3549,12 @@ function resolveWedgeConfig(env = process.env) {
     DEFAULTS.inboundWaitSeconds,
     30
   );
-  const inboundHardWaitSeconds = Math.max(
-    inboundWaitSeconds,
-    parsePositiveInt(env.AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS, DEFAULTS.inboundHardWaitSeconds, 30)
+  const inboundHardWaitRaw = parsePositiveInt(
+    env.AGT_WEDGE_INBOUND_HARD_WAIT_SECONDS,
+    DEFAULTS.inboundHardWaitSeconds,
+    0
   );
+  const inboundHardWaitSeconds = inboundHardWaitRaw <= 0 ? 0 : Math.max(inboundWaitSeconds, inboundHardWaitRaw);
   return {
     mode: parseMode(env.AGT_WEDGE_RESTART_MODE),
     inboundWaitSeconds,
@@ -3420,16 +3569,25 @@ function resolveWedgeConfig(env = process.env) {
   };
 }
 function isSessionProducing(signals, config2) {
+  const subagentAge = signals.subagentActivityAgeSeconds;
+  if (subagentAge !== null && subagentAge < config2.transcriptStaleSeconds) return true;
   const transcriptAge = signals.transcriptActivityAgeSeconds;
   if (transcriptAge !== null) return transcriptAge < config2.transcriptStaleSeconds;
   const paneAge = signals.paneActivityAgeSeconds;
   return paneAge !== null && paneAge < config2.paneStaleSeconds;
 }
+function wedgeExemptionReason(signals, config2) {
+  if (signals.subagentActivityAgeSeconds === null) return null;
+  if (isWedgeCandidateCycle(signals, config2)) return null;
+  const withoutSubagent = { ...signals, subagentActivityAgeSeconds: null };
+  return isWedgeCandidateCycle(withoutSubagent, config2) ? "background-task-in-flight" : null;
+}
 function isWedgeCandidateCycle(signals, config2) {
   const inboundAge = signals.pendingInboundOldestAgeSeconds;
   if (inboundAge === null) return false;
   if (inboundAge < config2.inboundWaitSeconds) return false;
   if (isSessionProducing(signals, config2)) {
+    if (config2.inboundHardWaitSeconds <= 0) return false;
     return inboundAge >= config2.inboundHardWaitSeconds;
   }
   return true;
@@ -3498,14 +3656,14 @@ function partitionActionableByPoison(actionable, states, config2) {
 
 // src/lib/restart-flags.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync8, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join7(homedir3(), ".augmented", "restart-flags");
+  return join8(homedir4(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join7(restartFlagsDir(), `${codeName}.flag`);
+  return join8(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
@@ -3514,7 +3672,7 @@ function readRestartFlags() {
   for (const entry of readdirSync3(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync8(join7(dir, entry), "utf8");
+      const raw = readFileSync8(join8(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -4062,8 +4220,8 @@ function applyRestartAcks(args) {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join8(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join8(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join9(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join9(AUGMENTED_DIR, "gateway-ports.json");
 var CHANNEL_SWEEP_INTERVAL_MS = (() => {
   const raw = parseInt(process.env["AGT_CHANNEL_SWEEP_INTERVAL_MS"] ?? "", 10);
   if (!Number.isFinite(raw)) return 5 * 60 * 1e3;
@@ -4399,6 +4557,7 @@ var DEFER_LOG_THROTTLE_MS = 6e5;
 var deferLogThrottle = /* @__PURE__ */ new Map();
 var lastInboundMs = /* @__PURE__ */ new Map();
 var consecutiveWedgeCycles = /* @__PURE__ */ new Map();
+var wedgeExemptionLogged = /* @__PURE__ */ new Set();
 var wedgeRestartsByCard = /* @__PURE__ */ new Map();
 function noteInbound(codeName) {
   lastInboundMs.set(codeName, Date.now());
@@ -4417,11 +4576,16 @@ function paneLogAgeSecondsFor(codeName) {
     return 0;
   }
 }
-function restartGateFor(codeName, breakerReason) {
-  if (!isGateableRestartReason(breakerReason)) return "bypass";
+function transcriptAgeSecondsFor(codeName) {
+  const sessionId = getSessionState(codeName)?.currentSessionId ?? null;
+  return transcriptActivityAgeSeconds(getProjectDir2(codeName), sessionId, /* @__PURE__ */ new Date());
+}
+function restartGateFor(codeName, reason) {
+  if (!isGateableRestartReason(reason)) return "bypass";
   return decideRestartGate({
     window: cachedMaintenanceWindow,
     paneLogAgeSeconds: paneLogAgeSecondsFor(codeName),
+    transcriptAgeSeconds: transcriptAgeSecondsFor(codeName),
     inboundAgeSeconds: inboundAgeSecondsFor(codeName),
     now: /* @__PURE__ */ new Date()
   });
@@ -4431,7 +4595,7 @@ var runningMcpServerKeys = /* @__PURE__ */ new Map();
 var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join9(projectDir, ".mcp.json"), "utf-8");
     return createHash3("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -4439,7 +4603,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join9(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -4450,7 +4614,7 @@ function projectMcpKeys(_codeName, projectDir) {
 }
 function readMcpHttpServerConfig(projectDir, serverKey, env) {
   try {
-    const raw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join9(projectDir, ".mcp.json"), "utf-8");
     const servers = JSON.parse(raw).mcpServers ?? {};
     const entry = servers[serverKey];
     if (entry && typeof entry.url === "string" && (entry.type === "http" || entry.type === void 0)) {
@@ -4478,7 +4642,7 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
   if (integrations.length === 0) return;
   const probeEnv = { ...process.env };
   try {
-    const envIntPath = join8(projectDir, ".env.integrations");
+    const envIntPath = join9(projectDir, ".env.integrations");
     if (existsSync5(envIntPath)) {
       Object.assign(probeEnv, parseEnvIntegrations(readFileSync9(envIntPath, "utf-8")));
     }
@@ -4580,10 +4744,10 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
     );
   }
 }
-function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason) {
-  const gate = restartGateFor(codeName, breakerReason);
+function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason, gateReason = breakerReason) {
+  const gate = restartGateFor(codeName, gateReason);
   if (gate !== "bypass" && gate !== "proceed") {
-    log(`[maintenance-window] Deferring '${breakerReason}' restart for '${codeName}' (${gate})`);
+    log(`[maintenance-window] Deferring '${gateReason}' restart for '${codeName}' (${gate})`);
     return;
   }
   cancelPendingSessionRestart(codeName);
@@ -4668,7 +4832,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync9(join8(projectDir, ".env.integrations"), "utf-8")
+      readFileSync9(join9(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -4760,7 +4924,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.150-test.16" : "dev";
+var agtCliVersion = true ? "0.27.150-test.17" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -5011,7 +5175,7 @@ async function ensureFrameworkBinary(frameworkId) {
 var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var claudeCodeUpgradeInFlight = false;
 function claudeCodeUpgradeMarkerPath() {
-  return join8(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
+  return join9(homedir5(), ".augmented", ".last-claude-code-upgrade-check");
 }
 function stampClaudeCodeUpgradeMarker() {
   try {
@@ -5074,7 +5238,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join8(homedir4(), ".augmented", ".last-self-update-applied");
+  return join9(homedir5(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -5097,7 +5261,7 @@ async function checkAndUpdateCli() {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return;
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join8(homedir4(), ".augmented", ".last-update-check");
+    const markerPath = join9(homedir5(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -5354,9 +5518,9 @@ 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 = join8(homedir4(), ".claude");
+    const claudeDir = join9(homedir5(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join8(claudeDir, filename);
+      const p = join9(claudeDir, filename);
       if (existsSync5(p)) {
         try {
           rmSync2(p, { force: true });
@@ -5372,12 +5536,12 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync5(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join8(homedir4(), ".augmented");
+  const dir = join9(homedir5(), ".augmented");
   try {
     mkdirSync4(dir, { recursive: true });
   } catch {
   }
-  const p = join8(dir, ".eval-empty-mcp.json");
+  const p = join9(dir, ".eval-empty-mcp.json");
   writeFileSync4(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
@@ -5403,7 +5567,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir4(),
+    cwd: homedir5(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -5482,10 +5646,10 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join8(config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join9(config?.configDir ?? join9(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join9(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -5496,7 +5660,7 @@ function saveChannelHashCache2() {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join9(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -5551,7 +5715,7 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join8(homedir4(), ".augmented", "manager.log");
+      managerLogPath = join9(homedir5(), ".augmented", "manager.log");
       mkdirSync4(dirname3(managerLogPath), { recursive: true });
       if (existsSync5(managerLogPath)) {
         chmodSync(managerLogPath, 384);
@@ -5606,12 +5770,12 @@ function parseSkillFrontmatter(content) {
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
   const { readdirSync: readdirSync5, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync5 } = await import("fs");
-  const skillsDir = join8(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join8(configDir, codeName, "project", "CLAUDE.md");
+  const skillsDir = join9(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join9(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync5(skillsDir).sort()) {
-    const skillFile = join8(skillsDir, dir, "SKILL.md");
+    const skillFile = join9(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -5659,7 +5823,7 @@ ${SKILLS_INDEX_END}`;
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join8(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join9(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
     sharedConfig = JSON.parse(readFileSync9(sharedConfigPath, "utf-8"));
@@ -5675,19 +5839,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join8(homeDir, `.openclaw-${codeName}`);
-    if (existsSync5(join8(profileDir, "openclaw.json"))) continue;
+    const profileDir = join9(homeDir, `.openclaw-${codeName}`);
+    if (existsSync5(join9(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join8(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join8(profileDir, "agents", codeName, "agent");
-    const authFile = join8(sharedAuthDir, "auth-profiles.json");
+    const sharedAuthDir = join9(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join9(profileDir, "agents", codeName, "agent");
+    const authFile = join9(sharedAuthDir, "auth-profiles.json");
     if (existsSync5(authFile)) {
       mkdirSync4(profileAuthDir, { recursive: true });
       const authContent = readFileSync9(authFile, "utf-8");
-      writeFileSync4(join8(profileAuthDir, "auth-profiles.json"), authContent);
+      writeFileSync4(join9(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -5725,7 +5889,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync9(join8(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync9(join9(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -5734,7 +5898,7 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const jobsPath = join9(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   if (!existsSync5(jobsPath)) return false;
   try {
     const data = JSON.parse(readFileSync9(jobsPath, "utf-8"));
@@ -5770,13 +5934,13 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join9(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join8(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          const configPath = join9(homeDir, `.openclaw-${codeName}`, "openclaw.json");
           if (existsSync5(configPath)) {
             const cfg = JSON.parse(readFileSync9(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
@@ -5802,7 +5966,7 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join8(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      const configPath = join9(homeDir, `.openclaw-${codeName}`, "openclaw.json");
       if (existsSync5(configPath)) {
         const cfg = JSON.parse(readFileSync9(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
@@ -5958,7 +6122,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-35PWSTLO.js");
+      const { collectDiagnostics } = await import("../persistent-session-IKQLTZZ6.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -6045,12 +6209,12 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-MA4M2QM4.js");
+      } = await import("../responsiveness-probe-2K4QHOWW.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
         if (probeCodeNames.length > 0) {
-          const { takeAcpxExecFailureCount, creditAcpxExecFailureCount } = await import("../persistent-session-35PWSTLO.js");
+          const { takeAcpxExecFailureCount, creditAcpxExecFailureCount } = await import("../persistent-session-IKQLTZZ6.js");
           const drainedGiveUps = /* @__PURE__ */ new Map();
           const drainedAcpxFailures = /* @__PURE__ */ new Map();
           const probes = collectResponsivenessProbes(probeCodeNames).map((p) => {
@@ -6084,14 +6248,16 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           deadLetterPendingInbound
-        } = await import("../responsiveness-probe-MA4M2QM4.js");
-        const { transcriptActivityAgeSeconds } = await import("../daily-session-PNQX5URX.js");
+        } = await import("../responsiveness-probe-2K4QHOWW.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
         for (const tracked of consecutiveWedgeCycles.keys()) {
           if (!liveAgents.has(tracked)) consecutiveWedgeCycles.delete(tracked);
         }
+        for (const tracked of wedgeExemptionLogged) {
+          if (!liveAgents.has(tracked)) wedgeExemptionLogged.delete(tracked);
+        }
         for (const tracked of wedgeRestartsByCard.keys()) {
           if (!liveAgents.has(tracked)) wedgeRestartsByCard.delete(tracked);
         }
@@ -6100,6 +6266,7 @@ async function pollCycle() {
           const codeName = probe.code_name;
           if (!isSessionHealthy(codeName)) {
             consecutiveWedgeCycles.delete(codeName);
+            wedgeExemptionLogged.delete(codeName);
             continue;
           }
           const wedgeSession = getSessionState(codeName);
@@ -6109,9 +6276,15 @@ async function pollCycle() {
             wedgeSession?.currentSessionId ?? null,
             wedgeNow
           );
+          const subagentAge = subagentActivityAgeSeconds(
+            wedgeProjectDir(codeName),
+            wedgeSession?.currentSessionId ?? null,
+            wedgeNow
+          );
           const signals = {
             paneActivityAgeSeconds: probe.pane_activity_age_seconds,
             transcriptActivityAgeSeconds: transcriptAge,
+            subagentActivityAgeSeconds: subagentAge,
             pendingInboundOldestAgeSeconds: livePendingInboundOldestAgeSeconds(
               codeName,
               sessionStartMs,
@@ -6120,8 +6293,20 @@ async function pollCycle() {
           };
           if (!isWedgeCandidateCycle(signals, wedgeConfig)) {
             consecutiveWedgeCycles.delete(codeName);
+            const exemption = wedgeExemptionReason(signals, wedgeConfig);
+            if (exemption !== null) {
+              if (!wedgeExemptionLogged.has(codeName)) {
+                wedgeExemptionLogged.add(codeName);
+                log(
+                  `[wedge] exempt agent=${codeName} reason=${exemption} subagentAge=${subagentAge}s inboundAge=${signals.pendingInboundOldestAgeSeconds}s transcriptAge=${transcriptAge === null ? "n/a" : `${transcriptAge}s`}`
+                );
+              }
+            } else {
+              wedgeExemptionLogged.delete(codeName);
+            }
             continue;
           }
+          wedgeExemptionLogged.delete(codeName);
           const streak = (consecutiveWedgeCycles.get(codeName) ?? 0) + 1;
           consecutiveWedgeCycles.set(codeName, streak);
           if (decideWedgeRestart({ ...signals, consecutiveWedgeCycles: streak }, wedgeConfig) !== "wedged") {
@@ -6149,6 +6334,21 @@ async function pollCycle() {
             log(
               `[wedge] forced fresh respawn ${detail} \u2192 new session ${newId} (transcript preserved${deadNote})`
             );
+            const wedgeAgentId = agentState.codeNameToAgentId.get(codeName);
+            if (wedgeAgentId) {
+              api.post("/host/wedge-respawn", {
+                agent_id: wedgeAgentId,
+                code_name: codeName,
+                dead_lettered_count: deadLettered,
+                pane_age_seconds: signals.paneActivityAgeSeconds,
+                inbound_age_seconds: signals.pendingInboundOldestAgeSeconds,
+                transcript_age_seconds: transcriptAge
+              }).catch((err) => {
+                log(
+                  `[wedge] failed to record respawn event for '${codeName}' (ENG-6265): ${err.message} \u2014 respawn proceeded; CloudWatch metric will under-count this event`
+                );
+              });
+            }
             const inProgressCardIds = (kanbanBoardCache.get(codeName) ?? []).filter((item) => item.status === "in_progress" && isHybridActionable(item)).map((item) => item.id);
             const cardStates = wedgeRestartsByCard.get(codeName) ?? /* @__PURE__ */ new Map();
             const { next, newlyPoisoned } = recordWedgeForCards(
@@ -6299,7 +6499,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join8(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join9(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -6385,10 +6585,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join8(homedir4(), ".augmented", codeName);
+          const dir = join9(homedir5(), ".augmented", codeName);
           if (!existsSync5(dir)) return;
           atomicWriteFileSync(
-            join8(dir, "watchdog-give-up.json"),
+            join9(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -6509,7 +6709,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join8(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join9(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -6713,7 +6913,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join8(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join9(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.migrateSecretStorage && !migratedSecretStorage.has(agent.code_name)) {
     try {
@@ -6756,7 +6956,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync4(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join8(agentDir, artifact.relativePath);
+      const filePath = join9(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -6775,7 +6975,7 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join8(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const projectClaudeMd = join9(config.configDir, agent.code_name, "project", "CLAUDE.md");
           const existing = readFileSync9(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
@@ -6816,12 +7016,12 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync5(join8(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync5(join9(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 = join8(agentDir, file.relativePath);
+        const filePath = join9(agentDir, file.relativePath);
         mkdirSync4(dirname3(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
@@ -6830,12 +7030,12 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const provSkillsDir = join8(agentDir, ".claude", "skills");
+        const provSkillsDir = join9(agentDir, ".claude", "skills");
         if (existsSync5(provSkillsDir)) {
           for (const folder of readdirSync4(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync2(join8(provSkillsDir, folder), { recursive: true });
+                rmSync2(join9(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -6848,7 +7048,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join8(agentDir, file));
+        const h = hashFile(join9(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -6916,7 +7116,7 @@ async function processAgent(agent, agentStates) {
   if (written && existsSync5(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join8(agentDir, file));
+      const localHash = hashFile(join9(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -6927,7 +7127,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join8(agentDir, file));
+          localHashes[file] = hashFile(join9(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -7251,18 +7451,18 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
+      const projectDir = join9(homedir5(), ".augmented", agent.code_name, "project");
       mkdirSync4(agentProvisionDir, { recursive: true });
       mkdirSync4(projectDir, { recursive: true });
-      const provisionMcpPath = join8(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join8(projectDir, ".mcp.json");
+      const provisionMcpPath = join9(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join9(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
         mcpConfig = JSON.parse(readFileSync9(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join8(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join9(homedir5(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -7292,7 +7492,7 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join8(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join9(projectDir, ".mcp-channels.json");
       if (existsSync5(staleChannelsPath)) {
         try {
           rmSync2(staleChannelsPath, { force: true });
@@ -7357,7 +7557,7 @@ async function processAgent(agent, agentStates) {
     }
     if (process.env.AGT_CONNECTIVITY_PROBE_ENABLED === "true") {
       try {
-        const probeProjectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join9(homedir5(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -7375,8 +7575,8 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
-        const envIntPath = join8(projectDir, ".env.integrations");
+        const projectDir = join9(homedir5(), ".augmented", agent.code_name, "project");
+        const envIntPath = join9(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
           preWriteEnv = readFileSync9(envIntPath, "utf-8");
@@ -7391,7 +7591,7 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join8(projectDir, ".mcp.json");
+            const projectMcpPath = join9(projectDir, ".mcp.json");
             const postWriteEnv = readFileSync9(envIntPath, "utf-8");
             const mcpContent = readFileSync9(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
@@ -7575,7 +7775,7 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join8(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        const pluginPath = join9(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
         if (existsSync5(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
@@ -7642,18 +7842,18 @@ async function processAgent(agent, agentStates) {
       }
       try {
         const { readdirSync: readdirSync5, rmSync: rmSync3 } = await import("fs");
-        const { homedir: homedir5 } = await import("os");
+        const { homedir: homedir6 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join8(homedir5(), ".augmented", agent.code_name, "skills"),
+          join9(homedir6(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join8(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join9(homedir6(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join8(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
+          join9(homedir6(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join8(agentDir, ".claude", "skills")
+          join9(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync5(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
@@ -7669,7 +7869,7 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join8(dir, entry);
+            const p = join9(dir, entry);
             if (existsSync5(p)) {
               rmSync3(p, { recursive: true, force: true });
             }
@@ -7849,7 +8049,7 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join8(getProjectDir(agent.code_name), ".mcp.json");
+        const mcpPath = join9(getProjectDir(agent.code_name), ".mcp.json");
         mcpJsonParsed = JSON.parse(readFileSync9(mcpPath, "utf-8"));
       } catch {
       }
@@ -7868,7 +8068,19 @@ async function processAgent(agent, agentStates) {
         // isolated and the agent keeps running degraded instead of being
         // paused wholesale. reaperRestartBreakerReason() encodes that
         // single-vs-multi decision; undefined means "restart, don't count".
-        stopSession: (codeName, ctx) => stopPersistentSessionAndForgetMcpBaseline(codeName, reaperRestartBreakerReason(ctx.activeKeys)),
+        //
+        // ENG-6264: the breaker-count reason (above, undefined for a single dead
+        // MCP) is decoupled from the GATE reason. Pre-6264 an undefined breaker
+        // reason also made the restart non-gateable → 'bypass' → the session was
+        // torn down mid-turn (the common single-MCP case interrupted busy
+        // agents). Always pass 'mcp-presence-reaper' as the gate reason so the
+        // restart defers-until-idle, while breakerReason still governs whether it
+        // counts against the breaker.
+        stopSession: (codeName, ctx) => stopPersistentSessionAndForgetMcpBaseline(
+          codeName,
+          reaperRestartBreakerReason(ctx.activeKeys),
+          "mcp-presence-reaper"
+        ),
         // ENG-5292: when the reaper gives up on a managed MCP (cap from
         // ENG-5279 + state-preservation from ENG-5285 both said "this
         // MCP keeps failing after 3 restart cycles"), mark the matching
@@ -8047,7 +8259,7 @@ async function processAgent(agent, agentStates) {
         lastWorkTriggerAt.set(agent.code_name, triggerTs);
         if (agentFw === "openclaw" && gatewayRunning && gatewayPort) {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const jobsPath = join8(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          const jobsPath = join9(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
           if (existsSync5(jobsPath)) {
             try {
               const jobsData = JSON.parse(readFileSync9(jobsPath, "utf-8"));
@@ -8187,7 +8399,7 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
   if (trackedFiles.length > 0 && existsSync5(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join8(agentDir, file));
+      const h = hashFile(join9(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -8221,16 +8433,16 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join8(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join9(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join8(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join9(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join9(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join8(sessionsDir, "sessions.json");
+  const indexPath = join9(sessionsDir, "sessions.json");
   if (!existsSync5(indexPath)) return;
   try {
     const raw = readFileSync9(indexPath, "utf-8");
@@ -8246,7 +8458,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join8(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join9(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
           if (existsSync5(sessionFile)) {
             unlinkSync(sessionFile);
@@ -8268,7 +8480,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join8(sessionsDir, `${parentSessionId}.jsonl`);
+            const f = join9(sessionsDir, `${parentSessionId}.jsonl`);
             if (existsSync5(f)) {
               unlinkSync(f);
               deletedFiles++;
@@ -8326,7 +8538,7 @@ function cleanupOldFiles(dir, maxAgeDays, ext) {
   try {
     for (const f of readdirSync4(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join8(dir, f);
+      const fullPath = join9(dir, f);
       try {
         const st = statSync3(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -8366,7 +8578,7 @@ var inFlightClaudeTasks = /* @__PURE__ */ new Set();
 var claudeTaskConcurrency = /* @__PURE__ */ new Map();
 var MAX_CLAUDE_CONCURRENCY = 2;
 function claudePidFilePath() {
-  return join8(homedir4(), ".augmented", "manager-claude-pids.json");
+  return join9(homedir5(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -8706,7 +8918,7 @@ async function fireScheduledTaskViaKanban(codeName, agentId, task, prompt) {
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join8(projectDir, ".mcp.json");
+  const mcpConfigPath = join9(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -8714,7 +8926,7 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join8(projectDir, "CLAUDE.md");
+    const claudeMdPath = join9(projectDir, "CLAUDE.md");
     const serverNames = [];
     if (existsSync5(mcpConfigPath)) {
       try {
@@ -8741,7 +8953,7 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join8(projectDir, ".env.integrations");
+    const envIntPath = join9(projectDir, ".env.integrations");
     if (existsSync5(envIntPath)) {
       try {
         Object.assign(childEnv, parseEnvIntegrations(readFileSync9(envIntPath, "utf-8")));
@@ -8916,8 +9128,8 @@ var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join8(projectDir, ".mcp.json");
-  const claudeMdPath = join8(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join9(projectDir, ".mcp.json");
+  const claudeMdPath = join9(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -9087,6 +9299,11 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
     } catch (err) {
       log(`[persistent-session] Failed to provision auto-progress hook for '${codeName}': ${err.message}`);
     }
+    try {
+      provisionSessionStateHook(codeName);
+    } catch (err) {
+      log(`[persistent-session] Failed to provision session-state hook for '${codeName}': ${err.message}`);
+    }
     const sessionRunResult = await startRun({
       agent_id: agent.agent_id,
       source_type: "system",
@@ -9546,7 +9763,7 @@ ${escapeXml(msg.content)}
       log(`[direct-chat] One-shot spawn for '${agent.codeName}' (msg=${msg.id}; host in-flight=${directChatSpawnGate.hostInFlight}, queued=${directChatSpawnGate.queuedCount})`);
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join8(projDir, ".mcp.json");
+      const mcpConfigPath = join9(projDir, ".mcp.json");
       const serverNames = [];
       if (existsSync5(mcpConfigPath)) {
         try {
@@ -9569,11 +9786,11 @@ ${escapeXml(msg.content)}
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join8(projDir, "CLAUDE.md");
+      const chatClaudeMd = join9(projDir, "CLAUDE.md");
       if (existsSync5(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join8(projDir, ".env.integrations");
+      const envIntPath = join9(projDir, ".env.integrations");
       const childEnv = { ...process.env };
       if (existsSync5(envIntPath)) {
         try {
@@ -9955,8 +10172,8 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join8(process.cwd(), "skills", skillId, "SKILL.md"),
-      join8(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join9(process.cwd(), "skills", skillId, "SKILL.md"),
+      join9(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync5(candidate)) {
@@ -10615,7 +10832,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-GIUCD7IG.js");
+  } = await import("../claude-pair-runtime-QYJUJUYY.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));
@@ -10676,11 +10893,11 @@ async function processClaudePairSessions(agents) {
           });
         } else {
           const errKind = result.error.kind;
-          const errMessage = "message" in result.error ? result.error.message : void 0;
+          const errMessage2 = "message" in result.error ? result.error.message : void 0;
           await reportAndCleanup(session.pair_id, {
             status: errKind === "no-session" ? "session_missing" : "failure",
             error_code: errKind,
-            error_message: errMessage
+            error_message: errMessage2
           });
         }
       } else if (session.status === "code_submitted" && session.code) {
@@ -10709,11 +10926,11 @@ async function processClaudePairSessions(agents) {
           });
         } else {
           const errKind = result.error.kind;
-          const errMessage = "message" in result.error ? result.error.message : void 0;
+          const errMessage2 = "message" in result.error ? result.error.message : void 0;
           await reportAndCleanup(session.pair_id, {
             status: errKind === "no-session" ? "session_missing" : "failure",
             error_code: errKind,
-            error_message: errMessage
+            error_message: errMessage2
           });
         }
       }
@@ -10925,8 +11142,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join8(configDir, agent.code_name, "project");
-  const memoryDir = join8(projectDir, "memory");
+  const projectDir = join9(configDir, agent.code_name, "project");
+  const memoryDir = join9(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`);
@@ -10944,7 +11161,7 @@ async function syncMemories(agent, configDir, log2) {
     for (const file of readdirSync4(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync9(join8(memoryDir, file), "utf-8");
+        const raw = readFileSync9(join9(memoryDir, file), "utf-8");
         const fileHash = createHash3("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -10969,7 +11186,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync9(join8(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync9(join9(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -11004,7 +11221,7 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join8(memoryDir, `${slug}.md`);
+        const filePath = join9(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -11125,6 +11342,42 @@ function stopCaffeinate() {
     log("caffeinate stopped");
   }
 }
+var artifactScanners = /* @__PURE__ */ new Map();
+var artifactStreamingInFlight = false;
+async function driveArtifactStreaming() {
+  if (artifactStreamingInFlight) return;
+  artifactStreamingInFlight = true;
+  try {
+    await driveArtifactStreamingInner();
+  } finally {
+    artifactStreamingInFlight = false;
+  }
+}
+async function driveArtifactStreamingInner() {
+  const liveIds = /* @__PURE__ */ new Set();
+  for (const agent of state6.agents) {
+    if (!agent.agentId || !agent.codeName || agent.status !== "active") continue;
+    liveIds.add(agent.agentId);
+    let scanner = artifactScanners.get(agent.agentId);
+    if (!scanner) {
+      scanner = new ArtifactStreamScanner(
+        agent.agentId,
+        artifactsDirFor(agent.codeName),
+        nodeArtifactFs,
+        { api, log }
+      );
+      artifactScanners.set(agent.agentId, scanner);
+    }
+    try {
+      await scanner.scanOnce();
+    } catch (err) {
+      log(`[artifact-stream] scan failed for ${agent.codeName}: ${err.message}`);
+    }
+  }
+  for (const id of artifactScanners.keys()) {
+    if (!liveIds.has(id)) artifactScanners.delete(id);
+  }
+}
 function startPolling() {
   if (!config || running) return;
   running = true;
@@ -11136,6 +11389,7 @@ function startPolling() {
     startGatewayPool();
     return pollCycle();
   }).then(() => {
+    void driveArtifactStreaming();
     scheduleNext();
   });
 }
@@ -11158,7 +11412,10 @@ function scheduleNext() {
       restartNow();
       return;
     }
-    void pollCycle().then(scheduleNext);
+    void pollCycle().then(() => {
+      void driveArtifactStreaming();
+      scheduleNext();
+    });
   }, delayMs);
 }
 async function killAllAgtTmuxSessions() {
@@ -11251,7 +11508,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=${join8(homedir4(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join9(homedir5(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -11382,14 +11639,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join8(homedir4(), ".augmented", "_mcp");
+  const targetDir = join9(homedir5(), ".augmented", "_mcp");
   mkdirSync4(targetDir, { recursive: true });
   const moduleDir = dirname3(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join8(dir, "dist", "mcp");
-    if (existsSync5(join8(candidate, "index.js"))) {
+    const candidate = join9(dir, "dist", "mcp");
+    if (existsSync5(join9(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -11432,8 +11689,8 @@ function deployMcpAssets() {
     // natural session restart.
     "augmented-admin.js"
   ]) {
-    const src = join8(mcpSourceDir, file);
-    const dst = join8(targetDir, file);
+    const src = join9(mcpSourceDir, file);
+    const dst = join9(targetDir, file);
     if (!existsSync5(src)) continue;
     const before = fileHash(dst);
     try {
@@ -11451,14 +11708,14 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join8(targetDir, "index.js");
+  const localMcpPath = join9(targetDir, "index.js");
   try {
-    const agentsDir = join8(homedir4(), ".augmented", "agents");
+    const agentsDir = join9(homedir5(), ".augmented", "agents");
     if (existsSync5(agentsDir)) {
       for (const entry of readdirSync4(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join8(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join9(agentsDir, entry.name, subdir, ".mcp.json");
           try {
             const raw = readFileSync9(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;