@integrity-labs/agt-cli 0.27.84 → 0.27.86

package/dist/lib/manager-worker.js

@@ -16,7 +16,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-WISOJYIV.js";
+} from "../chunk-SXE77YAJ.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -53,7 +53,7 @@ import {
   stopPersistentSession,
   takeWatchdogGiveUpCount,
   takeZombieDetection
-} from "../chunk-S2QLE5BQ.js";
+} from "../chunk-4LHN3FAL.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
@@ -76,7 +76,7 @@ import {
   resolveConnectivityProbe,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-TXE2LLKI.js";
+} from "../chunk-5IWPCN3V.js";
 import {
   parsePsRows,
   reapOrphanChannelMcps
@@ -84,10 +84,10 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, appendFileSync, mkdirSync as mkdirSync4, chmodSync, existsSync as existsSync5, rmSync as rmSync2, readdirSync as readdirSync3, statSync as statSync2, unlinkSync, copyFileSync } from "fs";
+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 join7, dirname as dirname3 } from "path";
+import { join as join8, dirname as dirname3 } from "path";
 import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
@@ -473,14 +473,14 @@ function reapMissingMcpSessions(args) {
     if (!missingRaw.includes(key)) liveKeys.add(key);
   }
   for (const key of liveKeys) {
-    const state5 = presenceReaperState.get(stateKey(codeName, key));
-    if (state5) {
-      state5.attempts = 0;
-      state5.lastSeenLiveAt = now();
-      state5.lastAttemptedSessionStartedAt = null;
-      state5.gaveUpLogged = false;
-      state5.firstMissingAt = null;
-      state5.quarantineLogged = false;
+    const state6 = presenceReaperState.get(stateKey(codeName, key));
+    if (state6) {
+      state6.attempts = 0;
+      state6.lastSeenLiveAt = now();
+      state6.lastAttemptedSessionStartedAt = null;
+      state6.gaveUpLogged = false;
+      state6.firstMissingAt = null;
+      state6.quarantineLogged = false;
     }
   }
   if (missing.length === 0) {
@@ -498,7 +498,7 @@ function reapMissingMcpSessions(args) {
   const wouldQuarantine = [];
   for (const key of missing) {
     const sk = stateKey(codeName, key);
-    const state5 = presenceReaperState.get(sk) ?? {
+    const state6 = presenceReaperState.get(sk) ?? {
       attempts: 0,
       lastSeenLiveAt: null,
       lastAttemptedSessionStartedAt: null,
@@ -506,19 +506,19 @@ function reapMissingMcpSessions(args) {
       firstMissingAt: null,
       quarantineLogged: false
     };
-    if (state5.firstMissingAt === null) state5.firstMissingAt = nowMs;
-    if (state5.lastAttemptedSessionStartedAt !== sessionStartedAt) {
-      state5.attempts += 1;
-      state5.lastAttemptedSessionStartedAt = sessionStartedAt;
+    if (state6.firstMissingAt === null) state6.firstMissingAt = nowMs;
+    if (state6.lastAttemptedSessionStartedAt !== sessionStartedAt) {
+      state6.attempts += 1;
+      state6.lastAttemptedSessionStartedAt = sessionStartedAt;
     }
-    presenceReaperState.set(sk, state5);
-    if (state5.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
+    presenceReaperState.set(sk, state6);
+    if (state6.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
       givenUp.push(key);
-      if (!state5.gaveUpLogged) {
+      if (!state6.gaveUpLogged) {
         log2(
           `[mcp-presence-reaper] giving up on '${codeName}:${key}' after ${MAX_PRESENCE_RESTART_ATTEMPTS} consecutive failed restarts \u2014 declared but never recovers (likely orphaned config; see ENG-5279)`
         );
-        state5.gaveUpLogged = true;
+        state6.gaveUpLogged = true;
         if (onGiveUp) {
           try {
             onGiveUp(codeName, key);
@@ -529,10 +529,10 @@ function reapMissingMcpSessions(args) {
           }
         }
       }
-      if (quarantineMode !== "off" && !state5.quarantineLogged && classifyKey(key) === "optional") {
-        const dwellElapsed = quarantineDwellMs <= 0 || state5.firstMissingAt !== null && nowMs - state5.firstMissingAt >= quarantineDwellMs;
+      if (quarantineMode !== "off" && !state6.quarantineLogged && classifyKey(key) === "optional") {
+        const dwellElapsed = quarantineDwellMs <= 0 || state6.firstMissingAt !== null && nowMs - state6.firstMissingAt >= quarantineDwellMs;
         if (dwellElapsed) {
-          state5.quarantineLogged = true;
+          state6.quarantineLogged = true;
           if (quarantineMode === "enforce") {
             quarantined.push(key);
             log2(
@@ -1647,14 +1647,272 @@ async function maybeReportTokenUsage(args) {
   state2.set(codeName, next);
 }
 
+// src/lib/conversation-evaluator.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { join as join3 } 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;
+var MAX_TURN_CHARS = 1500;
+var MAX_TRANSCRIPT_CHARS = 6e3;
+var DEFAULT_CLAUDE_EVAL_MODEL = "claude-haiku-4-5-20251001";
+var DEFAULT_LOCAL_EVAL_URL = "http://localhost:11434/v1/chat/completions";
+var DEFAULT_LOCAL_EVAL_MODEL = "gemma4:12b";
+var EVAL_TIMEOUT_MS = 12e4;
+async function runLocalEvalChat(prompt, opts) {
+  const endpoint = new URL(opts.url);
+  const hostname = endpoint.hostname.toLowerCase();
+  const isLoopback = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+  if (!isLoopback) {
+    throw new Error(`local eval url must be loopback-only, got host '${endpoint.hostname}'`);
+  }
+  const doFetch = opts.fetchImpl ?? fetch;
+  const res = await doFetch(opts.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      model: opts.model,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      max_tokens: 512,
+      stream: false
+    }),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? EVAL_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`local eval endpoint ${opts.url} returned ${res.status}`);
+  }
+  const data = await res.json();
+  const text = data.choices?.[0]?.message?.content;
+  if (typeof text !== "string" || !text.trim()) {
+    throw new Error("local eval endpoint returned no message content");
+  }
+  return text;
+}
+var state3 = /* @__PURE__ */ new Map();
+function channelRefTokens(channelRef) {
+  return channelRef.split(":").slice(1).filter((p) => p && p !== "dm");
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => {
+      if (typeof b === "string") return b;
+      if (b && typeof b === "object" && b.type === "text") {
+        return String(b.text ?? "");
+      }
+      return "";
+    }).filter(Boolean).join(" ");
+  }
+  return "";
+}
+function parseTranscriptTurns(jsonl) {
+  const turns = [];
+  for (const line of jsonl.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const role = obj.type === "user" || obj.type === "assistant" ? obj.type : void 0;
+    if (!role) continue;
+    const text = contentToText(obj.message?.content).trim();
+    if (!text) continue;
+    const ts = obj.timestamp ? Date.parse(obj.timestamp) : NaN;
+    turns.push({ role, text, ts: Number.isFinite(ts) ? ts : 0 });
+  }
+  return turns;
+}
+function stripChannelTag(text) {
+  return text.replace(/<channel\b[^>]*\/?>/i, "").replace(/<\/channel>/i, "").trim();
+}
+function reconstructConversation(allTurns, tokens, windowStartMs, windowEndMs) {
+  if (tokens.length === 0) return [];
+  const sorted = [...allTurns].sort((a, b) => a.ts - b.ts);
+  const out = [];
+  let inConversation = false;
+  for (const turn of sorted) {
+    if (turn.ts && (turn.ts < windowStartMs || turn.ts > windowEndMs)) continue;
+    if (turn.role === "user") {
+      inConversation = tokens.every((t) => turn.text.includes(t));
+      if (inConversation) {
+        out.push({ ...turn, text: stripChannelTag(turn.text) });
+      }
+    } else if (inConversation) {
+      out.push(turn);
+    }
+  }
+  return out;
+}
+function renderTranscript(turns) {
+  const lines = [];
+  let total = 0;
+  for (const turn of turns) {
+    const label = turn.role === "user" ? "User" : "Agent";
+    const body = turn.text.length > MAX_TURN_CHARS ? `${turn.text.slice(0, MAX_TURN_CHARS)}\u2026` : turn.text;
+    const line = `${label}: ${body}`;
+    if (total + line.length > MAX_TRANSCRIPT_CHARS) break;
+    lines.push(line);
+    total += line.length;
+  }
+  return lines.join("\n\n");
+}
+function buildEvalPrompt(channel, transcript) {
+  return `You are a strict QA evaluator scoring whether an AI agent successfully helped an end-user in a single ${channel} conversation. Judge ONLY the agent's effectiveness for the user \u2014 not tone, length, or policy.
+
+Conversation transcript:
+"""
+${transcript}
+"""
+
+Score the agent's success:
+- score: integer 0-100 (0 = ignored/unhelpful/wrong, 100 = fully resolved the user's need)
+- verdict: "success" (need clearly met), "partial" (some help but incomplete/ambiguous), or "failure" (did not help / made it worse)
+- summary: ONE short sentence (max 140 chars) explaining the score. Do NOT quote sensitive user content.
+
+Respond with ONLY a JSON object, no other text:
+{"score": 0-100, "verdict": "success|partial|failure", "summary": "..."}`;
+}
+function parseVerdict(raw) {
+  const match = raw.match(/\{[\s\S]*\}/);
+  if (!match) return null;
+  let obj;
+  try {
+    obj = JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+  const score = typeof obj.score === "number" ? obj.score : Number(obj.score);
+  if (!Number.isFinite(score) || score < 0 || score > 100) return null;
+  if (obj.verdict !== "success" && obj.verdict !== "partial" && obj.verdict !== "failure") return null;
+  const summary = typeof obj.summary === "string" ? obj.summary.slice(0, 140) : "";
+  return { score: Math.round(score), verdict: obj.verdict, summary };
+}
+async function maybeEvaluateConversations(args) {
+  const { api: api2, backend, codeName, agentId, log: log2 } = args;
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const existing = state3.get(codeName);
+  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS3) {
+    return;
+  }
+  state3.set(codeName, { lastCheckedAt: nowMs });
+  let pending;
+  try {
+    const resp = await api2.get(
+      `/host/conversations/pending-evaluation?agent_id=${encodeURIComponent(agentId)}`
+    );
+    pending = resp?.conversations ?? [];
+  } catch (err) {
+    log2(`[conversation-eval] ${codeName}: pending fetch failed: ${err.message}`);
+    return;
+  }
+  if (pending.length === 0) return;
+  const dir = args.transcriptDir ?? sessionTranscriptDir(getProjectDir(codeName));
+  const allTurns = readRecentTurns(dir, nowMs);
+  if (allTurns.length === 0) {
+    for (const conv of pending) {
+      await reportSkip(api2, agentId, conv.conversation_id, log2, codeName);
+    }
+    return;
+  }
+  for (const conv of pending) {
+    const tokens = channelRefTokens(conv.channel_ref);
+    const windowStart = Date.parse(conv.started_at) - WINDOW_PAD_MS;
+    const windowEnd = Date.parse(conv.last_message_at) + WINDOW_PAD_MS;
+    const turns = reconstructConversation(allTurns, tokens, windowStart, windowEnd);
+    if (turns.length === 0) {
+      await reportSkip(api2, agentId, conv.conversation_id, log2, codeName);
+      continue;
+    }
+    const transcript = renderTranscript(turns);
+    if (!transcript.trim()) {
+      await reportSkip(api2, agentId, conv.conversation_id, log2, codeName);
+      continue;
+    }
+    let verdict;
+    try {
+      const out = await backend.run(buildEvalPrompt(conv.channel, transcript));
+      verdict = parseVerdict(out);
+    } catch (err) {
+      log2(`[conversation-eval] ${codeName}: scoring failed: ${err.message}`);
+      continue;
+    }
+    if (!verdict) {
+      log2(`[conversation-eval] ${codeName}: unparseable verdict for ${conv.conversation_id.slice(0, 8)}`);
+      continue;
+    }
+    try {
+      await api2.post("/host/conversations/evaluation", {
+        agent_id: agentId,
+        conversation_id: conv.conversation_id,
+        score: verdict.score,
+        verdict: verdict.verdict,
+        summary: verdict.summary,
+        model: backend.model
+      });
+      log2(
+        `[conversation-eval] ${codeName}: ${conv.conversation_id.slice(0, 8)} \u2192 ${verdict.verdict} (${verdict.score})`
+      );
+    } catch (err) {
+      log2(`[conversation-eval] ${codeName}: report failed: ${err.message}`);
+    }
+  }
+}
+async function reportSkip(api2, agentId, conversationId, log2, codeName) {
+  try {
+    await api2.post("/host/conversations/evaluation", {
+      agent_id: agentId,
+      conversation_id: conversationId,
+      skipped: true
+    });
+  } catch (err) {
+    log2(`[conversation-eval] ${codeName}: skip report failed: ${err.message}`);
+  }
+}
+function readRecentTurns(dir, nowMs) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const turns = [];
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl")) continue;
+    const full = join3(dir, name);
+    let mtimeMs;
+    try {
+      mtimeMs = statSync2(full).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (nowMs - mtimeMs > TRANSCRIPT_MTIME_WINDOW_MS2) continue;
+    let content;
+    try {
+      content = readFileSync5(full, "utf8");
+    } catch {
+      continue;
+    }
+    turns.push(...parseTranscriptTurns(content));
+  }
+  return turns;
+}
+
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync6 } from "fs";
 import { homedir } from "os";
-import { join as join3 } from "path";
-var MIN_CHECK_INTERVAL_MS3 = 6e4;
-var STATS_CACHE_PATH = join3(homedir(), ".claude", "stats-cache.json");
+import { join as join4 } from "path";
+var MIN_CHECK_INTERVAL_MS4 = 6e4;
+var STATS_CACHE_PATH = join4(homedir(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var state3 = { lastObservedDate: null, lastCheckedAt: 0 };
+var state4 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
   let parsed;
   try {
@@ -1693,24 +1951,24 @@ async function maybeReportActivityCache(args) {
   const { api: api2, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  if (nowMs - state3.lastCheckedAt < MIN_CHECK_INTERVAL_MS3) return;
-  state3.lastCheckedAt = nowMs;
+  if (nowMs - state4.lastCheckedAt < MIN_CHECK_INTERVAL_MS4) return;
+  state4.lastCheckedAt = nowMs;
   if (!existsSync2(STATS_CACHE_PATH)) {
     return;
   }
   let raw;
   try {
-    raw = readFileSync5(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync6(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
   }
-  const rows = selectNewDailyRows(raw, state3.lastObservedDate);
+  const rows = selectNewDailyRows(raw, state4.lastObservedDate);
   if (rows.length === 0) return;
   for (const row of rows) {
     try {
       await api2.post("/host/activity-observations", row);
-      state3.lastObservedDate = row.date;
+      state4.lastObservedDate = row.date;
     } catch (err) {
       log2(
         `[activity-cache] POST /host/activity-observations failed for date=${row.date}: ${err.message}`
@@ -2150,7 +2408,7 @@ 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 join4 } from "path";
+import { join as join5 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
@@ -2165,8 +2423,8 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join4(homedir2(), ".claude", ".credentials.json"),
-    join4(homedir2(), ".claude", "credentials.json")
+    join5(homedir2(), ".claude", ".credentials.json"),
+    join5(homedir2(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
@@ -2174,8 +2432,8 @@ async function findClaudeCredentialsPaths() {
       const entries = await readdir("/home", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        candidates.push(join4("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join4("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join5("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join5("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -2267,18 +2525,18 @@ function normalize(value) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join5(configDir, CACHE_FILENAME);
+  return join6(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
   if (!existsSync3(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    parsed = JSON.parse(readFileSync7(path, "utf-8"));
   } catch {
     return;
   }
@@ -2732,24 +2990,24 @@ function clearAgentState(agentId, codeName) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
+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 join6 } from "path";
+import { join as join7 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join6(homedir3(), ".augmented", "restart-flags");
+  return join7(homedir3(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join6(restartFlagsDir(), `${codeName}.flag`);
+  return join7(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
   if (!existsSync4(dir)) return [];
   const out = [];
-  for (const entry of readdirSync2(dir)) {
+  for (const entry of readdirSync3(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync7(join6(dir, entry), "utf8");
+      const raw = readFileSync8(join7(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -3296,8 +3554,8 @@ function applyRestartAcks(args) {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join7(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join7(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join8(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join8(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;
@@ -3404,8 +3662,8 @@ var KNOWN_SAFE_TAIL_SIGNATURES = /* @__PURE__ */ new Set(["session_id_in_use"]);
 function shouldSkipRevokedCleanup(previousKnownStatus) {
   return previousKnownStatus === "revoked";
 }
-function hasRevokedResiduals(state5) {
-  return state5.gatewayRunning || state5.portAllocated || state5.provisionDirExists;
+function hasRevokedResiduals(state6) {
+  return state6.gatewayRunning || state6.portAllocated || state6.provisionDirExists;
 }
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var restartBreaker = new RestartBreaker();
@@ -3482,7 +3740,7 @@ function inboundAgeSecondsFor(codeName) {
 }
 function paneLogAgeSecondsFor(codeName) {
   try {
-    const mtimeMs = statSync2(paneLogPath(codeName)).mtimeMs;
+    const mtimeMs = statSync3(paneLogPath(codeName)).mtimeMs;
     return Math.max(0, Math.floor((Date.now() - mtimeMs) / 1e3));
   } catch (err) {
     if (err?.code === "ENOENT") return null;
@@ -3502,7 +3760,7 @@ var runningMcpHashes = /* @__PURE__ */ new Map();
 var runningMcpServerKeys = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
     return createHash3("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -3510,7 +3768,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join8(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -3521,7 +3779,7 @@ function projectMcpKeys(_codeName, projectDir) {
 }
 function readMcpHttpServerConfig(projectDir, serverKey) {
   try {
-    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync9(join8(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)) {
@@ -3674,7 +3932,7 @@ var taskDisplayInfo = /* @__PURE__ */ new Map();
 var agentChannelTokens = /* @__PURE__ */ new Map();
 var activeChannels = /* @__PURE__ */ new Map();
 var gatewaysStartedThisCycle = /* @__PURE__ */ new Set();
-var state4 = {
+var state5 = {
   pid: process.pid,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   lastPollAt: null,
@@ -3713,7 +3971,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.84" : "dev";
+var agtCliVersion = true ? "0.27.86" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3890,7 +4148,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
     if (existsSync5(path)) {
-      const raw = readFileSync8(path, "utf-8").trim();
+      const raw = readFileSync9(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -3962,7 +4220,7 @@ async function ensureFrameworkBinary(frameworkId) {
 var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var claudeCodeUpgradeInFlight = false;
 function claudeCodeUpgradeMarkerPath() {
-  return join7(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
+  return join8(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
 }
 function stampClaudeCodeUpgradeMarker() {
   try {
@@ -3972,7 +4230,7 @@ function stampClaudeCodeUpgradeMarker() {
 }
 function claudeCodeUpgradeThrottled() {
   try {
-    const lastCheck = parseInt(readFileSync8(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
+    const lastCheck = parseInt(readFileSync9(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
     if (!Number.isFinite(lastCheck)) return false;
     return Date.now() - lastCheck < CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS;
   } catch {
@@ -4025,7 +4283,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join7(homedir4(), ".augmented", ".last-self-update-applied");
+  return join8(homedir4(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -4048,7 +4306,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 = join7(homedir4(), ".augmented", ".last-update-check");
+    const markerPath = join8(homedir4(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -4305,9 +4563,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 = join7(homedir4(), ".claude");
+    const claudeDir = join8(homedir4(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join7(claudeDir, filename);
+      const p = join8(claudeDir, filename);
       if (existsSync5(p)) {
         try {
           rmSync2(p, { force: true });
@@ -4320,9 +4578,86 @@ async function applyClaudeAuthToEnv(childEnv, label) {
     delete childEnv.ANTHROPIC_API_KEY;
   }
 }
+var evalEmptyMcpConfigPath = null;
+function ensureEvalEmptyMcpConfig() {
+  if (evalEmptyMcpConfigPath && existsSync5(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join8(homedir4(), ".augmented");
+  try {
+    mkdirSync4(dir, { recursive: true });
+  } catch {
+  }
+  const p = join8(dir, ".eval-empty-mcp.json");
+  writeFileSync4(p, JSON.stringify({ mcpServers: {} }));
+  evalEmptyMcpConfigPath = p;
+  return p;
+}
+async function runEvalClaude(prompt, model) {
+  const childEnv = { ...process.env };
+  await applyClaudeAuthToEnv(childEnv, "conversation-eval");
+  const emptyMcp = ensureEvalEmptyMcpConfig();
+  const args = [
+    "-p",
+    prompt,
+    "--model",
+    model,
+    "--output-format",
+    "text",
+    // Isolation: only the empty MCP config, ignore project/user config + no tools.
+    "--mcp-config",
+    emptyMcp,
+    "--strict-mcp-config",
+    "--permission-mode",
+    "auto",
+    "--allowedTools",
+    ""
+  ];
+  const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
+    cwd: homedir4(),
+    timeout: 12e4,
+    stdin: "ignore",
+    env: childEnv,
+    onSpawn: (pid) => registerClaudeSpawn({ pid, started_at: Date.now(), kind: "other" }),
+    onExit: (pid) => unregisterClaudeSpawn(pid)
+  });
+  return stdout;
+}
+var conversationEvalBackend = null;
+function resolveConversationEvalBackend() {
+  if (conversationEvalBackend) return conversationEvalBackend;
+  const kind = (process.env["AGT_CONV_EVAL_BACKEND"] ?? "claude-p").trim().toLowerCase();
+  if (kind === "local") {
+    const url = process.env["AGT_CONV_EVAL_LOCAL_URL"]?.trim() || DEFAULT_LOCAL_EVAL_URL;
+    const model = process.env["AGT_CONV_EVAL_LOCAL_MODEL"]?.trim() || DEFAULT_LOCAL_EVAL_MODEL;
+    const apiKey = process.env["AGT_CONV_EVAL_LOCAL_API_KEY"]?.trim() || void 0;
+    const safeUrl = (() => {
+      try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+      } catch {
+        return "[invalid-url]";
+      }
+    })();
+    log(`[conversation-eval] backend=local url=${safeUrl} model=${model}`);
+    conversationEvalBackend = { model, run: (prompt) => runLocalEvalChat(prompt, { url, model, apiKey }) };
+    return conversationEvalBackend;
+  }
+  if (kind === "" || kind === "claude-p") {
+    const model = process.env["AGT_CONV_EVAL_CLAUDE_MODEL"]?.trim() || DEFAULT_CLAUDE_EVAL_MODEL;
+    conversationEvalBackend = { model, run: (prompt) => runEvalClaude(prompt, model) };
+    return conversationEvalBackend;
+  }
+  log(`[conversation-eval] invalid AGT_CONV_EVAL_BACKEND='${kind}' \u2014 expected 'claude-p' or 'local'; evaluation disabled`);
+  conversationEvalBackend = {
+    model: "invalid-conversation-eval-backend",
+    run: async () => {
+      throw new Error(`Unsupported AGT_CONV_EVAL_BACKEND='${kind}'. Expected 'claude-p' or 'local'.`);
+    }
+  };
+  return conversationEvalBackend;
+}
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync8(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync9(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
@@ -4352,10 +4687,10 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join7(config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join8(config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -4366,7 +4701,7 @@ function saveChannelHashCache2() {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join8(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -4421,7 +4756,7 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join7(homedir4(), ".augmented", "manager.log");
+      managerLogPath = join8(homedir4(), ".augmented", "manager.log");
       mkdirSync4(dirname3(managerLogPath), { recursive: true });
       if (existsSync5(managerLogPath)) {
         chmodSync(managerLogPath, 384);
@@ -4451,7 +4786,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -4475,13 +4810,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync4, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync5 } = await import("fs");
-  const skillsDir = join7(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join7(configDir, codeName, "project", "CLAUDE.md");
+  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");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
-  for (const dir of readdirSync4(skillsDir).sort()) {
-    const skillFile = join7(skillsDir, dir, "SKILL.md");
+  for (const dir of readdirSync5(skillsDir).sort()) {
+    const skillFile = join8(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -4529,10 +4864,10 @@ ${SKILLS_INDEX_END}`;
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join7(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join8(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync8(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync9(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -4545,19 +4880,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join7(homeDir, `.openclaw-${codeName}`);
-    if (existsSync5(join7(profileDir, "openclaw.json"))) continue;
+    const profileDir = join8(homeDir, `.openclaw-${codeName}`);
+    if (existsSync5(join8(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join7(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join7(profileDir, "agents", codeName, "agent");
-    const authFile = join7(sharedAuthDir, "auth-profiles.json");
+    const sharedAuthDir = join8(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join8(profileDir, "agents", codeName, "agent");
+    const authFile = join8(sharedAuthDir, "auth-profiles.json");
     if (existsSync5(authFile)) {
       mkdirSync4(profileAuthDir, { recursive: true });
-      const authContent = readFileSync8(authFile, "utf-8");
-      writeFileSync4(join7(profileAuthDir, "auth-profiles.json"), authContent);
+      const authContent = readFileSync9(authFile, "utf-8");
+      writeFileSync4(join8(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -4595,7 +4930,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync8(join7(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync9(join8(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -4604,18 +4939,18 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const jobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   if (!existsSync5(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync8(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync9(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
     for (const job of jobs) {
-      const state5 = job.state;
-      if (!state5) continue;
-      const runStartedAt = state5.runStartedAtMs;
-      const isRunning = state5.status === "running" || state5.running === true;
+      const state6 = job.state;
+      if (!state6) continue;
+      const runStartedAt = state6.runStartedAtMs;
+      const isRunning = state6.status === "running" || state6.running === true;
       if (isRunning && runStartedAt && now - runStartedAt > GATEWAY_HUNG_TIMEOUT_MS) {
         return true;
       }
@@ -4640,15 +4975,15 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join7(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          const configPath = join8(homeDir, `.openclaw-${codeName}`, "openclaw.json");
           if (existsSync5(configPath)) {
-            const cfg = JSON.parse(readFileSync8(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync9(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
@@ -4672,9 +5007,9 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join7(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      const configPath = join8(homeDir, `.openclaw-${codeName}`, "openclaw.json");
       if (existsSync5(configPath)) {
-        const cfg = JSON.parse(readFileSync8(configPath, "utf-8"));
+        const cfg = JSON.parse(readFileSync9(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
         writeFileSync4(configPath, JSON.stringify(cfg, null, 2));
@@ -4816,7 +5151,7 @@ async function pollCycle() {
     const now = Date.now();
     if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
       try {
-        const firstAgent = state4.agents[0];
+        const firstAgent = state5.agents[0];
         const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework("openclaw");
         if (versionAdapter.getVersion) {
           cachedFrameworkVersion = await versionAdapter.getVersion();
@@ -4827,7 +5162,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-BTXWOKJ6.js");
+      const { collectDiagnostics } = await import("../persistent-session-YNVCVUK3.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -4900,7 +5235,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-Y6TCM6T4.js");
+      } = await import("../responsiveness-probe-5ICEBNCM.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -4963,7 +5298,7 @@ async function pollCycle() {
     for (const agent of agents) {
       const requested = agent.restart_requested_at ?? null;
       if (!requested) continue;
-      const prev = state4.agents.find((a) => a.agentId === agent.agent_id);
+      const prev = state5.agents.find((a) => a.agentId === agent.agent_id);
       const lastProcessed = prev?.lastRestartProcessedAt ?? null;
       if (lastProcessed && Date.parse(lastProcessed) >= Date.parse(requested)) continue;
       log(`[restart] Dashboard requested restart for '${agent.code_name}' at ${requested}`);
@@ -4986,7 +5321,7 @@ async function pollCycle() {
         await processAgent(agent, agentStates);
       } catch (err) {
         log(`Error processing agent '${agent.code_name}': ${err.message}`);
-        const existing = state4.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state5.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
         } else {
@@ -5012,12 +5347,12 @@ async function pollCycle() {
     void maybeReportActivityCache({ api, log });
     const restartAckStateChanged = applyRestartAcks({
       agentStates,
-      priorAgents: state4.agents,
+      priorAgents: state5.agents,
       restartAcks
     });
     if (restartAckStateChanged) {
       try {
-        const ackedState = { ...state4, agents: agentStates };
+        const ackedState = { ...state5, agents: agentStates };
         atomicWriteFileSync(getStateFile(), JSON.stringify(ackedState, null, 2));
       } catch (err) {
         log(`[restart] failed to persist ack immediately: ${err.message}`);
@@ -5035,7 +5370,7 @@ async function pollCycle() {
     } catch {
     }
     const currentIds = new Set(agents.map((a) => a.agent_id));
-    for (const prev of state4.agents) {
+    for (const prev of state5.agents) {
       if (!currentIds.has(prev.agentId)) {
         log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
@@ -5048,7 +5383,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join7(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join8(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -5156,10 +5491,10 @@ async function pollCycle() {
       }
     } catch {
     }
-    state4 = {
-      ...state4,
+    state5 = {
+      ...state5,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pollCount: state4.pollCount + 1,
+      pollCount: state5.pollCount + 1,
       agents: agentStates,
       // ENG-5441: serialise trip state on every poll so manager restarts
       // never silently clear a tripped breaker. Cheap — only tripped
@@ -5170,9 +5505,9 @@ async function pollCycle() {
       log(`[poll-backoff] recovered after ${consecutivePollFailures} failure(s), resuming normal interval`);
       consecutivePollFailures = 0;
     }
-    send({ type: "state-update", state: state4 });
+    send({ type: "state-update", state: state5 });
   } catch (err) {
-    state4.errorCount++;
+    state5.errorCount++;
     const message = err.message;
     log(`Poll error: ${message}`);
     send({ type: "error", message });
@@ -5216,10 +5551,17 @@ async function processAgent(agent, agentStates) {
       agentId: agent.agent_id,
       log
     });
+    void maybeEvaluateConversations({
+      api,
+      backend: resolveConversationEvalBackend(),
+      codeName: agent.code_name,
+      agentId: agent.agent_id,
+      log
+    });
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join7(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join8(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`);
@@ -5340,7 +5682,7 @@ async function processAgent(agent, agentStates) {
     });
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
-    const existing = state4.agents.find((a) => a.agentId === agent.agent_id);
+    const existing = state5.agents.find((a) => a.agentId === agent.agent_id);
     agentStates.push(existing ?? {
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -5388,7 +5730,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join7(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join8(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.migrateSecretStorage && !migratedSecretStorage.has(agent.code_name)) {
     try {
@@ -5404,7 +5746,7 @@ async function processAgent(agent, agentStates) {
   const charterVersion = refreshData.charter.version;
   const toolsVersion = refreshData.tools.version;
   const known = agentState.knownVersions.get(agent.agent_id);
-  let lastProvisionAt = state4.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  let lastProvisionAt = state5.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(agent.code_name);
   const currentChannelIds = setWithout(
     launchableChannelIds(refreshData.channel_configs),
@@ -5431,7 +5773,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync4(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join7(agentDir, artifact.relativePath);
+      const filePath = join8(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -5450,8 +5792,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join7(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync8(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join8(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync9(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -5469,7 +5811,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync8(filePath, "utf-8");
+          existingRaw = readFileSync9(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -5491,12 +5833,12 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync5(join7(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync5(join8(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 = join7(agentDir, file.relativePath);
+        const filePath = join8(agentDir, file.relativePath);
         mkdirSync4(dirname3(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
@@ -5505,12 +5847,12 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const provSkillsDir = join7(agentDir, ".claude", "skills");
+        const provSkillsDir = join8(agentDir, ".claude", "skills");
         if (existsSync5(provSkillsDir)) {
-          for (const folder of readdirSync3(provSkillsDir)) {
+          for (const folder of readdirSync4(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync2(join7(provSkillsDir, folder), { recursive: true });
+                rmSync2(join8(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -5523,7 +5865,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join7(agentDir, file));
+        const h = hashFile(join8(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -5591,7 +5933,7 @@ async function processAgent(agent, agentStates) {
   if (written && existsSync5(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join7(agentDir, file));
+      const localHash = hashFile(join8(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -5602,7 +5944,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join7(agentDir, file));
+          localHashes[file] = hashFile(join8(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -5865,18 +6207,18 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
+      const projectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
       mkdirSync4(agentProvisionDir, { recursive: true });
       mkdirSync4(projectDir, { recursive: true });
-      const provisionMcpPath = join7(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join7(projectDir, ".mcp.json");
+      const provisionMcpPath = join8(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join8(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync8(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync9(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join7(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join8(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -5906,7 +6248,7 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join7(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join8(projectDir, ".mcp-channels.json");
       if (existsSync5(staleChannelsPath)) {
         try {
           rmSync2(staleChannelsPath, { force: true });
@@ -5917,7 +6259,7 @@ async function processAgent(agent, agentStates) {
       log(`Failed to provision direct-chat channel for '${agent.code_name}': ${err.message}`);
     }
   }
-  let lastSecretsProvisionAt = state4.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let lastSecretsProvisionAt = state5.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
   let secretsHash = agentState.knownSecretsHashes.get(agent.agent_id) ?? null;
   try {
     const secretsData = await api.post("/host/secrets", { agent_id: agent.agent_id });
@@ -5971,7 +6313,7 @@ async function processAgent(agent, agentStates) {
     }
     if (process.env.AGT_CONNECTIVITY_PROBE_ENABLED === "true") {
       try {
-        const probeProjectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -5981,11 +6323,11 @@ async function processAgent(agent, agentStates) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
-        const envIntPath = join7(projectDir, ".env.integrations");
+        const projectDir = join8(homedir4(), ".augmented", agent.code_name, "project");
+        const envIntPath = join8(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync8(envIntPath, "utf-8");
+          preWriteEnv = readFileSync9(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -5997,9 +6339,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join7(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync8(envIntPath, "utf-8");
-            const mcpContent = readFileSync8(projectMcpPath, "utf-8");
+            const projectMcpPath = join8(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync9(envIntPath, "utf-8");
+            const mcpContent = readFileSync9(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -6067,8 +6409,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync9 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync9(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync10 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync10(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
                     "composio_",
@@ -6164,7 +6506,7 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join7(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        const pluginPath = join8(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
         if (existsSync5(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
@@ -6230,25 +6572,25 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const { readdirSync: readdirSync4, rmSync: rmSync3 } = await import("fs");
+        const { readdirSync: readdirSync5, rmSync: rmSync3 } = await import("fs");
         const { homedir: homedir5 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join7(homedir5(), ".augmented", agent.code_name, "skills"),
+          join8(homedir5(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join7(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join8(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join7(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
+          join8(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join7(agentDir, ".claude", "skills")
+          join8(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync5(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
-            for (const entry of readdirSync4(dir)) {
+            for (const entry of readdirSync5(dir)) {
               if (entry.startsWith("plugin-") || entry.startsWith("integration-")) {
                 discoveredEntries.add(entry);
               }
@@ -6258,7 +6600,7 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join7(dir, entry);
+            const p = join8(dir, entry);
             if (existsSync5(p)) {
               rmSync3(p, { recursive: true, force: true });
             }
@@ -6420,8 +6762,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join7(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync8(mcpPath, "utf-8"));
+        const mcpPath = join8(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync9(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -6606,10 +6948,10 @@ async function processAgent(agent, agentStates) {
         lastWorkTriggerAt.set(agent.code_name, triggerTs);
         if (agentFw === "openclaw" && gatewayRunning && gatewayPort) {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const jobsPath = join7(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          const jobsPath = join8(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
           if (existsSync5(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync8(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync9(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -6746,7 +7088,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(join7(agentDir, file));
+      const h = hashFile(join8(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -6780,19 +7122,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join7(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join8(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join7(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join8(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join8(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join7(sessionsDir, "sessions.json");
+  const indexPath = join8(sessionsDir, "sessions.json");
   if (!existsSync5(indexPath)) return;
   try {
-    const raw = readFileSync8(indexPath, "utf-8");
+    const raw = readFileSync9(indexPath, "utf-8");
     const index = JSON.parse(raw);
     const cronRunKeys = Object.keys(index).filter((k) => k.includes(":cron:") && k.includes(":run:")).map((k) => ({
       key: k,
@@ -6805,7 +7147,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join7(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join8(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
           if (existsSync5(sessionFile)) {
             unlinkSync(sessionFile);
@@ -6827,7 +7169,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join7(sessionsDir, `${parentSessionId}.jsonl`);
+            const f = join8(sessionsDir, `${parentSessionId}.jsonl`);
             if (existsSync5(f)) {
               unlinkSync(f);
               deletedFiles++;
@@ -6848,26 +7190,26 @@ var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
   if (!existsSync5(jobsPath)) return;
   try {
-    const raw = readFileSync8(jobsPath, "utf-8");
+    const raw = readFileSync9(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
     let changed = false;
     const now = Date.now();
     for (const job of jobs) {
-      const state5 = job.state;
-      if (!state5) continue;
-      const runStartedAt = state5.runningAtMs ?? state5.runStartedAtMs;
-      const isRunning = state5.running === true || state5.status === "running";
+      const state6 = job.state;
+      if (!state6) continue;
+      const runStartedAt = state6.runningAtMs ?? state6.runStartedAtMs;
+      const isRunning = state6.running === true || state6.status === "running";
       if (isRunning && runStartedAt && now - runStartedAt > STALE_RUN_TIMEOUT_MS) {
-        state5.running = false;
-        delete state5.status;
-        delete state5.runStartedAtMs;
-        delete state5.currentRunId;
+        state6.running = false;
+        delete state6.status;
+        delete state6.runStartedAtMs;
+        delete state6.currentRunId;
         changed = true;
         log(`Cleared stale running state for cron job '${job.name}' (stuck for ${Math.round((now - runStartedAt) / 6e4)}min)`);
       } else if (isRunning && !runStartedAt) {
-        state5.running = false;
+        state6.running = false;
         changed = true;
         log(`Cleared stale running state for cron job '${job.name}' (no start timestamp)`);
       }
@@ -6883,11 +7225,11 @@ function cleanupOldFiles(dir, maxAgeDays, ext) {
   const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
   let removed = 0;
   try {
-    for (const f of readdirSync3(dir)) {
+    for (const f of readdirSync4(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join7(dir, f);
+      const fullPath = join8(dir, f);
       try {
-        const st = statSync2(fullPath);
+        const st = statSync3(fullPath);
         if (st.mtimeMs < cutoff) {
           unlinkSync(fullPath);
           removed++;
@@ -6905,7 +7247,7 @@ var inFlightClaudeTasks = /* @__PURE__ */ new Set();
 var claudeTaskConcurrency = /* @__PURE__ */ new Map();
 var MAX_CLAUDE_CONCURRENCY = 2;
 function claudePidFilePath() {
-  return join7(homedir4(), ".augmented", "manager-claude-pids.json");
+  return join8(homedir4(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -6950,16 +7292,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
       enabled: t.enabled ?? true,
       triggered_at: t.triggered_at ?? null
     }));
-    const state6 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state6);
+    const state7 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state7);
     agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
     log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state5 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state5, inFlightClaudeTasks);
+  const state6 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state6, inFlightClaudeTasks);
   if (ready.length === 0) return;
   for (const task of ready) {
     if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
@@ -7106,8 +7448,8 @@ async function deliverScheduledCardResult(codeName, agentId, cardId) {
     markScheduledCardDeliveryComplete(cardId);
     return "terminal";
   }
-  const state5 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const task = state5.tasks[card.source_ref];
+  const state6 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state6.tasks[card.source_ref];
   if (!task) {
     log(`[scheduled-kanban] delivery: no scheduler task for source_ref=${card.source_ref} on '${codeName}' \u2014 skipping`);
     markScheduledCardDeliveryComplete(cardId);
@@ -7213,7 +7555,7 @@ async function fireScheduledTaskViaKanban(codeName, agentId, task, prompt) {
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join7(projectDir, ".mcp.json");
+  const mcpConfigPath = join8(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -7221,11 +7563,11 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join7(projectDir, "CLAUDE.md");
+    const claudeMdPath = join8(projectDir, "CLAUDE.md");
     const serverNames = [];
     if (existsSync5(mcpConfigPath)) {
       try {
-        const d = JSON.parse(readFileSync8(mcpConfigPath, "utf-8"));
+        const d = JSON.parse(readFileSync9(mcpConfigPath, "utf-8"));
         if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
       } catch {
       }
@@ -7248,10 +7590,10 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join7(projectDir, ".env.integrations");
+    const envIntPath = join8(projectDir, ".env.integrations");
     if (existsSync5(envIntPath)) {
       try {
-        Object.assign(childEnv, parseEnvIntegrations(readFileSync8(envIntPath, "utf-8")));
+        Object.assign(childEnv, parseEnvIntegrations(readFileSync9(envIntPath, "utf-8")));
       } catch {
       }
     }
@@ -7423,8 +7765,8 @@ var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join7(projectDir, ".mcp.json");
-  const claudeMdPath = join7(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join8(projectDir, ".mcp.json");
+  const claudeMdPath = join8(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -7651,9 +7993,9 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state5 = claudeSchedulerStates.get(codeName);
-  if (state5) {
-    const ready = getReadyTasks(state5, inFlightClaudeTasks);
+  const state6 = claudeSchedulerStates.get(codeName);
+  if (state6) {
+    const ready = getReadyTasks(state6, inFlightClaudeTasks);
     if (ready.length > 0) {
       log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
     }
@@ -8064,11 +8406,11 @@ ${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-EM24LTGV.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join7(projDir, ".mcp.json");
+      const mcpConfigPath = join8(projDir, ".mcp.json");
       const serverNames = [];
       if (existsSync5(mcpConfigPath)) {
         try {
-          const d = JSON.parse(readFileSync8(mcpConfigPath, "utf-8"));
+          const d = JSON.parse(readFileSync9(mcpConfigPath, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -8087,15 +8429,15 @@ ${escapeXml(msg.content)}
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join7(projDir, "CLAUDE.md");
+      const chatClaudeMd = join8(projDir, "CLAUDE.md");
       if (existsSync5(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join7(projDir, ".env.integrations");
+      const envIntPath = join8(projDir, ".env.integrations");
       const childEnv = { ...process.env };
       if (existsSync5(envIntPath)) {
         try {
-          Object.assign(childEnv, parseEnvIntegrations(readFileSync8(envIntPath, "utf-8")));
+          Object.assign(childEnv, parseEnvIntegrations(readFileSync9(envIntPath, "utf-8")));
         } catch {
         }
       }
@@ -8473,12 +8815,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join7(process.cwd(), "skills", skillId, "SKILL.md"),
-      join7(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join8(process.cwd(), "skills", skillId, "SKILL.md"),
+      join8(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync5(candidate)) {
-        const content = readFileSync8(candidate, "utf-8");
+        const content = readFileSync9(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -9121,7 +9463,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-MKK7LSQG.js");
+  } = await import("../claude-pair-runtime-DY2LN3ED.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));
@@ -9431,8 +9773,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join7(configDir, agent.code_name, "project");
-  const memoryDir = join7(projectDir, "memory");
+  const projectDir = join8(configDir, agent.code_name, "project");
+  const memoryDir = join8(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`);
@@ -9447,10 +9789,10 @@ async function syncMemories(agent, configDir, log2) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
-    for (const file of readdirSync3(memoryDir)) {
+    for (const file of readdirSync4(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync8(join7(memoryDir, file), "utf-8");
+        const raw = readFileSync9(join8(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;
@@ -9475,7 +9817,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync8(join7(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync9(join8(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -9488,7 +9830,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync5(memoryDir) ? readdirSync3(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync5(memoryDir) ? readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash3("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -9510,7 +9852,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 = join7(memoryDir, `${slug}.md`);
+        const filePath = join8(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -9522,7 +9864,7 @@ ${mem.content}
         if (existsSync5(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync8(filePath, "utf-8");
+            existing = readFileSync9(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
@@ -9534,7 +9876,7 @@ ${mem.content}
         }
       }
       if (written > 0 || overwritten > 0) {
-        const updatedFiles = readdirSync3(memoryDir).filter((f) => f.endsWith(".md")).sort();
+        const updatedFiles = readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).sort();
         lastLocalFileHash.set(agent.agent_id, createHash3("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
@@ -9736,11 +10078,11 @@ function startManager(opts) {
   try {
     const stateFile = getStateFile();
     if (existsSync5(stateFile)) {
-      const raw = readFileSync8(stateFile, "utf-8");
+      const raw = readFileSync9(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
-        state4.agents = parsed.agents;
-        log(`[startup] rehydrated ${state4.agents.length} agent state(s) from ${stateFile}`);
+        state5.agents = parsed.agents;
+        log(`[startup] rehydrated ${state5.agents.length} agent state(s) from ${stateFile}`);
       }
       if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
         restartBreaker.hydrate(parsed.circuitBreakerTrips);
@@ -9752,7 +10094,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=${join7(homedir4(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join8(homedir4(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -9773,7 +10115,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync8(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync9(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -9883,14 +10225,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join7(homedir4(), ".augmented", "_mcp");
+  const targetDir = join8(homedir4(), ".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 = join7(dir, "dist", "mcp");
-    if (existsSync5(join7(candidate, "index.js"))) {
+    const candidate = join8(dir, "dist", "mcp");
+    if (existsSync5(join8(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -9906,7 +10248,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync5(p)) return null;
-      return createHash3("sha256").update(readFileSync8(p)).digest("hex");
+      return createHash3("sha256").update(readFileSync9(p)).digest("hex");
     } catch {
       return null;
     }
@@ -9927,8 +10269,8 @@ function deployMcpAssets() {
     "teams-channel.js"
     // ENG-6019
   ]) {
-    const src = join7(mcpSourceDir, file);
-    const dst = join7(targetDir, file);
+    const src = join8(mcpSourceDir, file);
+    const dst = join8(targetDir, file);
     if (!existsSync5(src)) continue;
     const before = fileHash(dst);
     try {
@@ -9946,16 +10288,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join7(targetDir, "index.js");
+  const localMcpPath = join8(targetDir, "index.js");
   try {
-    const agentsDir = join7(homedir4(), ".augmented", "agents");
+    const agentsDir = join8(homedir4(), ".augmented", "agents");
     if (existsSync5(agentsDir)) {
-      for (const entry of readdirSync3(agentsDir, { withFileTypes: true })) {
+      for (const entry of readdirSync4(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join7(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join8(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync8(mcpJsonPath, "utf-8");
+            const raw = readFileSync9(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];