@integrity-labs/agt-cli 0.27.128 → 0.27.129

package/dist/bin/agt.js

@@ -28,7 +28,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-TXZLQK3S.js";
+} from "../chunk-A64MR5QP.js";
 import {
   CHANNEL_REGISTRY,
   DEPLOYMENT_TEMPLATES,
@@ -4934,7 +4934,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.27.128" : "dev";
+var cliVersion = true ? "0.27.129" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5857,7 +5857,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.27.128" : "dev";
+var cliVersion2 = true ? "0.27.129" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-TXZLQK3S.js → chunk-A64MR5QP.js}

@@ -7653,4 +7653,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-TXZLQK3S.js.map
+//# sourceMappingURL=chunk-A64MR5QP.js.map

package/dist/lib/manager-worker.js

@@ -17,7 +17,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-TXZLQK3S.js";
+} from "../chunk-A64MR5QP.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -502,14 +502,14 @@ function reapMissingMcpSessions(args) {
     if (!missingRaw.includes(key)) liveKeys.add(key);
   }
   for (const key of liveKeys) {
-    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;
+    const state7 = presenceReaperState.get(stateKey(codeName, key));
+    if (state7) {
+      state7.attempts = 0;
+      state7.lastSeenLiveAt = now();
+      state7.lastAttemptedSessionStartedAt = null;
+      state7.gaveUpLogged = false;
+      state7.firstMissingAt = null;
+      state7.quarantineLogged = false;
     }
   }
   if (missing.length === 0) {
@@ -527,7 +527,7 @@ function reapMissingMcpSessions(args) {
   const wouldQuarantine = [];
   for (const key of missing) {
     const sk = stateKey(codeName, key);
-    const state6 = presenceReaperState.get(sk) ?? {
+    const state7 = presenceReaperState.get(sk) ?? {
       attempts: 0,
       lastSeenLiveAt: null,
       lastAttemptedSessionStartedAt: null,
@@ -535,19 +535,19 @@ function reapMissingMcpSessions(args) {
       firstMissingAt: null,
       quarantineLogged: false
     };
-    if (state6.firstMissingAt === null) state6.firstMissingAt = nowMs;
-    if (state6.lastAttemptedSessionStartedAt !== sessionStartedAt) {
-      state6.attempts += 1;
-      state6.lastAttemptedSessionStartedAt = sessionStartedAt;
+    if (state7.firstMissingAt === null) state7.firstMissingAt = nowMs;
+    if (state7.lastAttemptedSessionStartedAt !== sessionStartedAt) {
+      state7.attempts += 1;
+      state7.lastAttemptedSessionStartedAt = sessionStartedAt;
     }
-    presenceReaperState.set(sk, state6);
-    if (state6.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
+    presenceReaperState.set(sk, state7);
+    if (state7.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
       givenUp.push(key);
-      if (!state6.gaveUpLogged) {
+      if (!state7.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)`
         );
-        state6.gaveUpLogged = true;
+        state7.gaveUpLogged = true;
         if (onGiveUp) {
           try {
             onGiveUp(codeName, key);
@@ -558,10 +558,10 @@ function reapMissingMcpSessions(args) {
           }
         }
       }
-      if (quarantineMode !== "off" && !state6.quarantineLogged && classifyKey(key) === "optional") {
-        const dwellElapsed = quarantineDwellMs <= 0 || state6.firstMissingAt !== null && nowMs - state6.firstMissingAt >= quarantineDwellMs;
+      if (quarantineMode !== "off" && !state7.quarantineLogged && classifyKey(key) === "optional") {
+        const dwellElapsed = quarantineDwellMs <= 0 || state7.firstMissingAt !== null && nowMs - state7.firstMissingAt >= quarantineDwellMs;
         if (dwellElapsed) {
-          state6.quarantineLogged = true;
+          state7.quarantineLogged = true;
           if (quarantineMode === "enforce") {
             quarantined.push(key);
             log2(
@@ -2101,14 +2101,173 @@ function readRecentTurns(dir, nowMs) {
   return turns;
 }
 
+// src/lib/memory-extractor.ts
+var MIN_CHECK_INTERVAL_MS4 = 10 * 6e4;
+var WINDOW_PAD_MS2 = 5 * 6e4;
+var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["user", "feedback", "project", "reference"]);
+var SECRET_PATTERNS = [
+  // labelled secrets: `api_key=...`, `password: ...`, `bearer ...`
+  /\b[\w-]*(?:secret|password|passwd|token|api[_-]?key|bearer)[\w-]*\s*[=:]\s*\S+/gi,
+  // common credential prefixes (stripe, github, slack, augmented host keys, …)
+  /\b(?:sk|pk|rk|tlk|ghp|gho|ghs|xox[baprs])[-_][A-Za-z0-9]{12,}\b/g,
+  // long hex blobs (hashes / hex-encoded keys)
+  /\b[A-Fa-f0-9]{32,}\b/g,
+  // long base64 blobs (tokens / encoded secrets)
+  /\b[A-Za-z0-9+/]{40,}={0,2}\b/g,
+  // email addresses
+  /\b[\w.+-]+@[\w-]+\.[\w.-]+\b/g
+];
+function scrubSensitive(text) {
+  let out = text;
+  for (const re of SECRET_PATTERNS) out = out.replace(re, "[redacted]");
+  return out;
+}
+var state4 = /* @__PURE__ */ new Map();
+function buildExtractionPrompt(channel, transcript) {
+  return `You are extracting durable, reusable memories from one completed ${channel} conversation between an AI agent and an end-user. A good memory is a stable preference, fact, correction, or recurring work context that will help the agent in FUTURE conversations \u2014 not a one-off task detail or pleasantry.
+
+Conversation transcript:
+"""
+${transcript}
+"""
+
+Extract 0-5 candidate memories. For each:
+- name: short descriptive title (max 50 chars)
+- content: the memory itself, self-contained (max 200 chars). Do NOT include secrets or sensitive personal data.
+- type: "user" (a person's stable preference), "feedback" (a correction to how the agent should work), "project" (durable work context), or "reference" (a pointer to an external resource)
+- confidence: 0.0-1.0 \u2014 how sure you are this is worth remembering long-term
+- rationale: why this should persist (max 100 chars)
+
+If there is nothing durable worth remembering, return an empty array. Do NOT invent memories to fill the list.
+
+Respond with ONLY a JSON array, no other text:
+[{"name":"...","content":"...","type":"...","confidence":0.8,"rationale":"..."}]`;
+}
+function parseCandidates(raw) {
+  const match = raw.match(/\[[\s\S]*\]/);
+  if (!match) return null;
+  let arr;
+  try {
+    arr = JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(arr)) return null;
+  const out = [];
+  for (const entry of arr) {
+    if (!entry || typeof entry !== "object") continue;
+    const c = entry;
+    const name = typeof c.name === "string" ? c.name.trim() : "";
+    if (!name) continue;
+    if (typeof c.type !== "string" || !VALID_MEMORY_TYPES.has(c.type)) continue;
+    const confidence = typeof c.confidence === "number" && Number.isFinite(c.confidence) ? Math.max(0, Math.min(1, c.confidence)) : 0;
+    if (confidence === 0) continue;
+    out.push({
+      name: name.slice(0, 80),
+      content: (typeof c.content === "string" ? c.content : "").trim().slice(0, 500),
+      type: c.type,
+      confidence,
+      rationale: (typeof c.rationale === "string" ? c.rationale : "").trim().slice(0, 200)
+    });
+  }
+  return out;
+}
+async function maybeExtractMemories(args) {
+  const { api: api2, backend, codeName, agentId, log: log2 } = args;
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const existing = state4.get(codeName);
+  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS4) {
+    return;
+  }
+  state4.set(codeName, { lastCheckedAt: nowMs });
+  let pending;
+  try {
+    const resp = await api2.get(
+      `/host/memories/pending-extraction?agent_id=${encodeURIComponent(agentId)}`
+    );
+    pending = resp?.conversations ?? [];
+  } catch (err) {
+    log2(`[memory-extract] ${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 reportSkip2(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_MS2;
+    const windowEnd = Date.parse(conv.last_message_at) + WINDOW_PAD_MS2;
+    const turns = reconstructConversation(allTurns, tokens, windowStart, windowEnd);
+    if (turns.length === 0) {
+      await reportSkip2(api2, agentId, conv.conversation_id, log2, codeName);
+      continue;
+    }
+    const transcript = renderTranscript(turns);
+    if (!transcript.trim()) {
+      await reportSkip2(api2, agentId, conv.conversation_id, log2, codeName);
+      continue;
+    }
+    let candidates;
+    try {
+      const out = await backend.run(buildExtractionPrompt(conv.channel, transcript));
+      candidates = parseCandidates(out);
+    } catch (err) {
+      log2(`[memory-extract] ${codeName}: extraction failed: ${err.message}`);
+      continue;
+    }
+    if (candidates === null) {
+      log2(`[memory-extract] ${codeName}: unparseable output for ${conv.conversation_id.slice(0, 8)} \u2014 will retry`);
+      continue;
+    }
+    const scrubbed = candidates.map((c) => ({
+      ...c,
+      content: scrubSensitive(c.content),
+      rationale: scrubSensitive(c.rationale)
+    }));
+    try {
+      const res = await api2.post(
+        "/host/memories/candidates",
+        {
+          agent_id: agentId,
+          conversation_id: conv.conversation_id,
+          candidates: scrubbed
+        }
+      );
+      log2(
+        `[memory-extract] ${codeName}: ${conv.conversation_id.slice(0, 8)} \u2192 ${candidates.length} candidate(s), ${res?.promoted ?? 0} promoted`
+      );
+    } catch (err) {
+      log2(`[memory-extract] ${codeName}: report failed: ${err.message}`);
+    }
+  }
+}
+async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
+  try {
+    await api2.post("/host/memories/candidates", {
+      agent_id: agentId,
+      conversation_id: conversationId,
+      skipped: true
+    });
+  } catch (err) {
+    log2(`[memory-extract] ${codeName}: skip report failed: ${err.message}`);
+  }
+}
+
 // 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";
-var MIN_CHECK_INTERVAL_MS4 = 6e4;
+var MIN_CHECK_INTERVAL_MS5 = 6e4;
 var STATS_CACHE_PATH = join4(homedir(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var state4 = { lastObservedDate: null, lastCheckedAt: 0 };
+var state5 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
   let parsed;
   try {
@@ -2147,8 +2306,8 @@ async function maybeReportActivityCache(args) {
   const { api: api2, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  if (nowMs - state4.lastCheckedAt < MIN_CHECK_INTERVAL_MS4) return;
-  state4.lastCheckedAt = nowMs;
+  if (nowMs - state5.lastCheckedAt < MIN_CHECK_INTERVAL_MS5) return;
+  state5.lastCheckedAt = nowMs;
   if (!existsSync2(STATS_CACHE_PATH)) {
     return;
   }
@@ -2159,12 +2318,12 @@ async function maybeReportActivityCache(args) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
   }
-  const rows = selectNewDailyRows(raw, state4.lastObservedDate);
+  const rows = selectNewDailyRows(raw, state5.lastObservedDate);
   if (rows.length === 0) return;
   for (const row of rows) {
     try {
       await api2.post("/host/activity-observations", row);
-      state4.lastObservedDate = row.date;
+      state5.lastObservedDate = row.date;
     } catch (err) {
       log2(
         `[activity-cache] POST /host/activity-observations failed for date=${row.date}: ${err.message}`
@@ -3278,10 +3437,10 @@ function recordWedgeForCards(states, inProgressCardIds, nowMs, config2) {
 function pruneCardStates(states, liveInProgressCardIds, nowMs, config2) {
   const live = liveInProgressCardIds instanceof Set ? liveInProgressCardIds : new Set(liveInProgressCardIds);
   const next = /* @__PURE__ */ new Map();
-  for (const [id, state6] of states) {
+  for (const [id, state7] of states) {
     if (!live.has(id)) continue;
-    if (nowMs - state6.lastWedgeAtMs > config2.cooldownMs) continue;
-    next.set(id, state6);
+    if (nowMs - state7.lastWedgeAtMs > config2.cooldownMs) continue;
+    next.set(id, state7);
   }
   return next;
 }
@@ -3971,8 +4130,8 @@ var KNOWN_SAFE_TAIL_SIGNATURES = /* @__PURE__ */ new Set(["session_id_in_use"]);
 function shouldSkipRevokedCleanup(previousKnownStatus) {
   return previousKnownStatus === "revoked";
 }
-function hasRevokedResiduals(state6) {
-  return state6.gatewayRunning || state6.portAllocated || state6.provisionDirExists;
+function hasRevokedResiduals(state7) {
+  return state7.gatewayRunning || state7.portAllocated || state7.provisionDirExists;
 }
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var pendingRestartVerifications = /* @__PURE__ */ new Map();
@@ -4077,12 +4236,12 @@ function maybeAutoResume(agent) {
       autoResumeMarkers.set(codeName, { trippedAt, autoResumedAt: Date.now() });
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
-      state5 = {
-        ...state5,
+      state6 = {
+        ...state6,
         circuitBreakerTrips: restartBreaker.serialize(),
         circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
       };
-      send({ type: "state-update", state: state5 });
+      send({ type: "state-update", state: state6 });
       log(`[auto-resume] agent=${codeName} resumed \u2014 re-trip within backoff window will stay paused (ENG-6088)`);
     } else {
       autoResumeStandDowns.add(`${codeName}:${trippedAt}`);
@@ -4452,7 +4611,7 @@ function __setAgentChannelTokensForTest(codeName, tokens) {
 }
 var activeChannels = /* @__PURE__ */ new Map();
 var gatewaysStartedThisCycle = /* @__PURE__ */ new Set();
-var state5 = {
+var state6 = {
   pid: process.pid,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   lastPollAt: null,
@@ -4494,7 +4653,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.128" : "dev";
+var agtCliVersion = true ? "0.27.129" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -5146,6 +5305,10 @@ async function runEvalClaude(prompt, model) {
   });
   return stdout;
 }
+function memoryExtractionEnabled() {
+  const v = (process.env["AGT_MEMORY_EXTRACTION_ENABLED"] ?? "").trim().toLowerCase();
+  return v === "true" || v === "1" || v === "yes";
+}
 var conversationEvalBackend = null;
 function resolveConversationEvalBackend() {
   if (conversationEvalBackend) return conversationEvalBackend;
@@ -5472,10 +5635,10 @@ function isGatewayHung(codeName) {
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
     for (const job of jobs) {
-      const state6 = job.state;
-      if (!state6) continue;
-      const runStartedAt = state6.runStartedAtMs;
-      const isRunning = state6.status === "running" || state6.running === true;
+      const state7 = job.state;
+      if (!state7) continue;
+      const runStartedAt = state7.runStartedAtMs;
+      const isRunning = state7.status === "running" || state7.running === true;
       if (isRunning && runStartedAt && now - runStartedAt > GATEWAY_HUNG_TIMEOUT_MS) {
         return true;
       }
@@ -5676,7 +5839,7 @@ async function pollCycle() {
     const now = Date.now();
     if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
       try {
-        const firstAgent = state5.agents[0];
+        const firstAgent = state6.agents[0];
         const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework("openclaw");
         if (versionAdapter.getVersion) {
           cachedFrameworkVersion = await versionAdapter.getVersion();
@@ -5720,7 +5883,7 @@ async function pollCycle() {
         const errId = createHash3("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
-      const hostHasClaudeCode = state5.agents.some(
+      const hostHasClaudeCode = state6.agents.some(
         (a) => agentFrameworkCache.get(a.codeName) === "claude-code"
       );
       if (hostHasClaudeCode) {
@@ -5933,7 +6096,7 @@ async function pollCycle() {
     for (const agent of agents) {
       const requested = agent.restart_requested_at ?? null;
       if (!requested) continue;
-      const prev = state5.agents.find((a) => a.agentId === agent.agent_id);
+      const prev = state6.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}`);
@@ -5956,7 +6119,7 @@ async function pollCycle() {
         await processAgent(agent, agentStates);
       } catch (err) {
         log(`Error processing agent '${agent.code_name}': ${err.message}`);
-        const existing = state5.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state6.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
         } else {
@@ -5982,12 +6145,12 @@ async function pollCycle() {
     void maybeReportActivityCache({ api, log });
     const restartAckStateChanged = applyRestartAcks({
       agentStates,
-      priorAgents: state5.agents,
+      priorAgents: state6.agents,
       restartAcks
     });
     if (restartAckStateChanged) {
       try {
-        const ackedState = { ...state5, agents: agentStates };
+        const ackedState = { ...state6, agents: agentStates };
         atomicWriteFileSync(getStateFile(), JSON.stringify(ackedState, null, 2));
       } catch (err) {
         log(`[restart] failed to persist ack immediately: ${err.message}`);
@@ -6005,7 +6168,7 @@ async function pollCycle() {
     } catch {
     }
     const currentIds = new Set(agents.map((a) => a.agent_id));
-    for (const prev of state5.agents) {
+    for (const prev of state6.agents) {
       if (!currentIds.has(prev.agentId)) {
         log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
@@ -6146,10 +6309,10 @@ async function pollCycle() {
       }
     } catch {
     }
-    state5 = {
-      ...state5,
+    state6 = {
+      ...state6,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pollCount: state5.pollCount + 1,
+      pollCount: state6.pollCount + 1,
       agents: agentStates,
       // ENG-5441: serialise trip state on every poll so manager restarts
       // never silently clear a tripped breaker. Cheap — only tripped
@@ -6163,9 +6326,9 @@ async function pollCycle() {
       consecutivePollFailures = 0;
     }
     verifyPendingRestarts(Date.now());
-    send({ type: "state-update", state: state5 });
+    send({ type: "state-update", state: state6 });
   } catch (err) {
-    state5.errorCount++;
+    state6.errorCount++;
     const message = err.message;
     log(`Poll error: ${message}`);
     send({ type: "error", message });
@@ -6216,6 +6379,15 @@ async function processAgent(agent, agentStates) {
       agentId: agent.agent_id,
       log
     });
+    if (memoryExtractionEnabled()) {
+      void maybeExtractMemories({
+        api,
+        backend: resolveConversationEvalBackend(),
+        codeName: agent.code_name,
+        agentId: agent.agent_id,
+        log
+      });
+    }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
@@ -6340,11 +6512,11 @@ async function processAgent(agent, agentStates) {
       const marker = autoResumeMarkers.get(agent.code_name);
       const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
       if (!isSelfResume && autoResumeMarkers.delete(agent.code_name)) {
-        state5 = {
-          ...state5,
+        state6 = {
+          ...state6,
           circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
         };
-        send({ type: "state-update", state: state5 });
+        send({ type: "state-update", state: state6 });
         log(`[auto-resume] Cleared auto-resume marker for '${agent.code_name}' on operator resume \u2014 credit re-armed (ENG-6088)`);
       }
     }
@@ -6375,7 +6547,7 @@ async function processAgent(agent, agentStates) {
     });
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
-    const existing = state5.agents.find((a) => a.agentId === agent.agent_id);
+    const existing = state6.agents.find((a) => a.agentId === agent.agent_id);
     agentStates.push(existing ?? {
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -6439,7 +6611,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 = state5.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  let lastProvisionAt = state6.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(agent.code_name);
   const currentChannelIds = setWithout(
     launchableChannelIds(refreshData.channel_configs),
@@ -7003,7 +7175,7 @@ async function processAgent(agent, agentStates) {
       log(`Failed to provision direct-chat channel for '${agent.code_name}': ${err.message}`);
     }
   }
-  let lastSecretsProvisionAt = state5.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let lastSecretsProvisionAt = state6.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 });
@@ -7996,19 +8168,19 @@ function clearStaleCronRunState(jobsPath) {
     let changed = false;
     const now = Date.now();
     for (const job of jobs) {
-      const state6 = job.state;
-      if (!state6) continue;
-      const runStartedAt = state6.runningAtMs ?? state6.runStartedAtMs;
-      const isRunning = state6.running === true || state6.status === "running";
+      const state7 = job.state;
+      if (!state7) continue;
+      const runStartedAt = state7.runningAtMs ?? state7.runStartedAtMs;
+      const isRunning = state7.running === true || state7.status === "running";
       if (isRunning && runStartedAt && now - runStartedAt > STALE_RUN_TIMEOUT_MS) {
-        state6.running = false;
-        delete state6.status;
-        delete state6.runStartedAtMs;
-        delete state6.currentRunId;
+        state7.running = false;
+        delete state7.status;
+        delete state7.runStartedAtMs;
+        delete state7.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) {
-        state6.running = false;
+        state7.running = false;
         changed = true;
         log(`Cleared stale running state for cron job '${job.name}' (no start timestamp)`);
       }
@@ -8095,16 +8267,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state7 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state7);
+    const state8 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state8);
     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 state6 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state6, inFlightClaudeTasks);
+  const state7 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state7, inFlightClaudeTasks);
   if (ready.length === 0) return;
   for (const task of ready) {
     if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
@@ -8264,8 +8436,8 @@ async function deliverScheduledCardResult(codeName, agentId, cardId) {
     markScheduledCardDeliveryComplete(cardId);
     return "terminal";
   }
-  const state6 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const task = state6.tasks[card.source_ref];
+  const state7 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state7.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);
@@ -8828,9 +9000,9 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state6 = claudeSchedulerStates.get(codeName);
-  if (state6) {
-    const ready = getReadyTasks(state6, inFlightClaudeTasks);
+  const state7 = claudeSchedulerStates.get(codeName);
+  if (state7) {
+    const ready = getReadyTasks(state7, 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(", ")}`);
     }
@@ -10928,8 +11100,8 @@ function startManager(opts) {
       const raw = readFileSync9(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
-        state5.agents = parsed.agents;
-        log(`[startup] rehydrated ${state5.agents.length} agent state(s) from ${stateFile}`);
+        state6.agents = parsed.agents;
+        log(`[startup] rehydrated ${state6.agents.length} agent state(s) from ${stateFile}`);
       }
       if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
         restartBreaker.hydrate(parsed.circuitBreakerTrips);