@integrity-labs/agt-cli 0.28.37 → 0.28.38

package/dist/lib/manager-worker.js

@@ -23,7 +23,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-T3CD664K.js";
+} from "../chunk-IJT4B5PH.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -106,7 +106,7 @@ import {
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync9, rmSync as rmSync3, readdirSync as readdirSync5, statSync as statSync4, unlinkSync, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
 import { join as join16, dirname as dirname4 } from "path";
@@ -4433,11 +4433,140 @@ async function sendTaskNotification(agentCodeName, channel, to, text) {
   return { ok: false, error_code: `UNKNOWN_CHANNEL:${channel}` };
 }
 
-// src/lib/manager/scheduler.ts
+// src/lib/manager/scheduler/tasks.ts
+function buildSchedulerTaskInput(t) {
+  return {
+    id: t.id,
+    template_id: t.template_id,
+    name: t.name,
+    schedule_kind: t.schedule_kind,
+    schedule_expr: t.schedule_expr ?? null,
+    schedule_every: t.schedule_every ?? null,
+    schedule_at: t.schedule_at ?? null,
+    timezone: t.timezone ?? "UTC",
+    prompt: t.prompt ?? "",
+    session_target: t.session_target ?? "isolated",
+    delivery_mode: t.delivery_mode ?? "none",
+    delivery_policy: t.delivery_policy ?? "always",
+    delivery_channel: t.delivery_channel ?? null,
+    delivery_to: t.delivery_to ?? null,
+    enabled: t.enabled ?? true,
+    triggered_at: t.triggered_at ?? null
+  };
+}
+function deriveScheduledTaskNotify(task) {
+  if (task.deliveryChannel !== "msteams") return {};
+  const to = task.deliveryTo;
+  let conversationId = null;
+  if (typeof to === "string" && to.trim().length > 0) {
+    conversationId = to.trim();
+  } else if (to && typeof to === "object") {
+    const cid = to.conversation_id;
+    if (typeof cid === "string" && cid.trim().length > 0) conversationId = cid.trim();
+  }
+  if (!conversationId) return {};
+  return { notify_channel: "msteams", notify_to: conversationId };
+}
+function isScheduledViaKanbanEnabled() {
+  const v = process.env["AGT_SCHEDULED_VIA_KANBAN"];
+  return !(v === "0" || v?.toLowerCase() === "false");
+}
+
+// src/lib/manager/scheduler/runs.ts
 import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync12, existsSync as existsSync7 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join14 } from "path";
+async function startRun(opts) {
+  try {
+    const res = await api.post(
+      "/host/runs/start",
+      opts
+    );
+    return { run_id: res.run_id ?? null, kanban_item_id: res.kanban_item_id ?? null };
+  } catch (err) {
+    const errText = err instanceof Error ? err.message : String(err);
+    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
+    log(`[runs] start failed for agent_id=${opts.agent_id} source_type=${opts.source_type} error_id=${errId}`);
+    return { run_id: null, kanban_item_id: null };
+  }
+}
+async function finishRun(runId, outcome, options = {}) {
+  try {
+    await api.post("/host/runs/finish", {
+      run_id: runId,
+      outcome,
+      outcome_message: options.outcomeMessage,
+      metadata: options.metadata,
+      complete_kanban_item_id: options.completeKanbanItemId ?? void 0,
+      result: options.result
+    });
+  } catch (err) {
+    const errText = err instanceof Error ? err.message : String(err);
+    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
+    log(`[runs] finish failed for run_id=${runId} outcome=${outcome} error_id=${errId}`);
+  }
+}
+var MAX_PRIOR_RUNS = 5;
+async function fetchPriorScheduledRuns(agentId, taskId) {
+  try {
+    const data = await api.post("/host/scheduled-tasks/recent-outputs", {
+      agent_id: agentId,
+      task_id: taskId,
+      since_hours: 24,
+      limit: MAX_PRIOR_RUNS
+    });
+    const rows = Array.isArray(data?.runs) ? data.runs.slice(0, MAX_PRIOR_RUNS) : [];
+    return rows.filter((r) => typeof r.output_text === "string" && r.output_text.length > 0).map((r) => ({ startedAt: r.started_at, output: r.output_text }));
+  } catch (err) {
+    const errText = err instanceof Error ? err.message : String(err);
+    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
+    log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
+    return [];
+  }
+}
+
+// src/lib/manager/scheduler/state.ts
+var inFlightClaudeTasks = /* @__PURE__ */ new Set();
+var claudeTaskConcurrency = /* @__PURE__ */ new Map();
+var MAX_CLAUDE_CONCURRENCY = 2;
+var claudeSchedulerStates = /* @__PURE__ */ new Map();
+var scheduledRunsByCode = /* @__PURE__ */ new Map();
+var claimedScheduledCards = /* @__PURE__ */ new Set();
+var completedScheduledCards = /* @__PURE__ */ new Set();
+function claimScheduledCardDelivery(cardId) {
+  if (claimedScheduledCards.has(cardId)) return false;
+  claimedScheduledCards.add(cardId);
+  return true;
+}
+function releaseScheduledCardDelivery(cardId) {
+  claimedScheduledCards.delete(cardId);
+}
+function markScheduledCardDeliveryComplete(cardId) {
+  completedScheduledCards.add(cardId);
+}
+function trackScheduledRun(codeName, cardId, runId) {
+  let m = scheduledRunsByCode.get(codeName);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    scheduledRunsByCode.set(codeName, m);
+  }
+  m.set(cardId, runId);
+}
+function isScheduledCardTracked(cardId) {
+  for (const m of scheduledRunsByCode.values()) {
+    if (m.has(cardId)) return true;
+  }
+  return false;
+}
+function closeScheduledRunsForCode(codeName, outcome, reason) {
+  const m = scheduledRunsByCode.get(codeName);
+  if (!m || m.size === 0) return;
+  scheduledRunsByCode.delete(codeName);
+  for (const runId of m.values()) {
+    void finishRun(runId, outcome, { outcomeMessage: reason });
+  }
+}
+
+// src/lib/manager/scheduler/kanban-route.ts
+import { createHash as createHash6 } from "crypto";
 
 // src/lib/delivery-schedule-link.ts
 function envSuffixFor2(codeName) {
@@ -4663,250 +4792,57 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
   }
 }
 
-// src/lib/manager/scheduler.ts
-function buildSchedulerTaskInput(t) {
-  return {
-    id: t.id,
-    template_id: t.template_id,
-    name: t.name,
-    schedule_kind: t.schedule_kind,
-    schedule_expr: t.schedule_expr ?? null,
-    schedule_every: t.schedule_every ?? null,
-    schedule_at: t.schedule_at ?? null,
-    timezone: t.timezone ?? "UTC",
-    prompt: t.prompt ?? "",
-    session_target: t.session_target ?? "isolated",
-    delivery_mode: t.delivery_mode ?? "none",
-    delivery_policy: t.delivery_policy ?? "always",
-    delivery_channel: t.delivery_channel ?? null,
-    delivery_to: t.delivery_to ?? null,
-    enabled: t.enabled ?? true,
-    triggered_at: t.triggered_at ?? null
-  };
-}
-var inFlightClaudeTasks = /* @__PURE__ */ new Set();
-var claudeTaskConcurrency = /* @__PURE__ */ new Map();
-var MAX_CLAUDE_CONCURRENCY = 2;
-function claudePidFilePath() {
-  return join14(homedir7(), ".augmented", "manager-claude-pids.json");
-}
-var inFlightClaudePids = /* @__PURE__ */ new Map();
-function registerClaudeSpawn(record) {
-  inFlightClaudePids.set(record.pid, record);
+// src/lib/manager/scheduler/kanban-route.ts
+async function deliverScheduledCardResult(codeName, agentId, cardId) {
+  if (!claimScheduledCardDelivery(cardId)) {
+    return completedScheduledCards.has(cardId) ? "terminal" : "in_flight";
+  }
+  let card;
   try {
-    addSpawn(claudePidFilePath(), record);
+    const resp = await api.post("/host/kanban-item", {
+      agent_id: agentId,
+      item_id: cardId
+    });
+    card = resp.item;
   } catch (err) {
-    log(`[drain] pid-file write failed: ${err.message}`);
+    if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
+      log(`[scheduled-kanban] delivery: card ${cardId} on '${codeName}' fetch returned ${err.status} (${err.message}) \u2014 treating as terminal, not retrying`);
+      markScheduledCardDeliveryComplete(cardId);
+      return "terminal";
+    }
+    releaseScheduledCardDelivery(cardId);
+    log(`[scheduled-kanban] delivery fetch failed for card ${cardId} on '${codeName}': ${err.message} \u2014 will retry`);
+    return "retry";
   }
-}
-function unregisterClaudeSpawn(pid) {
-  inFlightClaudePids.delete(pid);
-  try {
-    removeSpawn(claudePidFilePath(), pid);
-  } catch {
+  if (!card || card.status !== "done" || card.source_type !== "scheduled_task" || !card.source_ref) {
+    markScheduledCardDeliveryComplete(cardId);
+    return "terminal";
   }
-}
-var claudeSchedulerStates = /* @__PURE__ */ new Map();
-async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
-  const codeName = agent.code_name;
-  const stableTasksHash = createHash5("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const boardHash = boardItems.length > 0 ? createHash5("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
-  const resolvedModels = resolveModelChain(refreshData);
-  const modelsHash = createHash5("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
-  const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
-  const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
-  if (combinedHash !== prevHash) {
-    const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    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))`);
+  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);
+    return "terminal";
   }
-  if (!claudeSchedulerStates.has(codeName)) {
-    claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
+  if (!isPlainScheduledTemplate(task.templateId)) {
+    log(`[scheduled-kanban] delivery: card ${cardId} template '${task.templateId}' on '${codeName}' is not a plain scheduled template \u2014 skipping manager delivery`);
+    markScheduledCardDeliveryComplete(cardId);
+    return "terminal";
   }
-  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;
-    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
-      const updated = markTaskFired(codeName, task.taskId, "ok");
-      claudeSchedulerStates.set(codeName, updated);
-      continue;
-    }
-    let prompt = task.prompt;
-    if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
-      const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
-      const boardPrefix = formatBoardForPrompt(boardItems, template);
-      prompt = boardPrefix + prompt;
-    }
-    inFlightClaudeTasks.add(task.taskId);
-    claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
-    if (isScheduledViaKanbanEnabled() && isPlainScheduledTemplate(task.templateId)) {
-      await fireScheduledTaskViaKanban(codeName, agent.agent_id, task, prompt);
-      inFlightClaudeTasks.delete(task.taskId);
-      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
-      continue;
+  const deliveryPolicy = task.deliveryPolicy ?? "always";
+  if (deliveryPolicy === "never" || deliveryPolicy === "conditional" && card.suppress_delivery !== false) {
+    log(
+      `[scheduled-kanban] Suppressed by delivery_policy=${deliveryPolicy} for card ${cardId} (task '${task.name}') on '${codeName}' \u2014 result recorded on the card only (tombstone)`
+    );
+    if (task.deliveryMode === "announce" && task.deliveryTo) {
+      await reportDeliveryStatus(agentId, task.taskId, {
+        status: "skipped",
+        error_code: "SUPPRESSED_BY_POLICY"
+      });
     }
-    log(`[claude-scheduler] Firing '${task.name}' for '${codeName}'`);
-    executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).finally(() => {
-      inFlightClaudeTasks.delete(task.taskId);
-      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
-    });
-  }
-}
-function deriveScheduledTaskNotify(task) {
-  if (task.deliveryChannel !== "msteams") return {};
-  const to = task.deliveryTo;
-  let conversationId = null;
-  if (typeof to === "string" && to.trim().length > 0) {
-    conversationId = to.trim();
-  } else if (to && typeof to === "object") {
-    const cid = to.conversation_id;
-    if (typeof cid === "string" && cid.trim().length > 0) conversationId = cid.trim();
-  }
-  if (!conversationId) return {};
-  return { notify_channel: "msteams", notify_to: conversationId };
-}
-async function startRun(opts) {
-  try {
-    const res = await api.post(
-      "/host/runs/start",
-      opts
-    );
-    return { run_id: res.run_id ?? null, kanban_item_id: res.kanban_item_id ?? null };
-  } catch (err) {
-    const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
-    log(`[runs] start failed for agent_id=${opts.agent_id} source_type=${opts.source_type} error_id=${errId}`);
-    return { run_id: null, kanban_item_id: null };
-  }
-}
-async function finishRun(runId, outcome, options = {}) {
-  try {
-    await api.post("/host/runs/finish", {
-      run_id: runId,
-      outcome,
-      outcome_message: options.outcomeMessage,
-      metadata: options.metadata,
-      complete_kanban_item_id: options.completeKanbanItemId ?? void 0,
-      result: options.result
-    });
-  } catch (err) {
-    const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
-    log(`[runs] finish failed for run_id=${runId} outcome=${outcome} error_id=${errId}`);
-  }
-}
-var MAX_PRIOR_RUNS = 5;
-async function fetchPriorScheduledRuns(agentId, taskId) {
-  try {
-    const data = await api.post("/host/scheduled-tasks/recent-outputs", {
-      agent_id: agentId,
-      task_id: taskId,
-      since_hours: 24,
-      limit: MAX_PRIOR_RUNS
-    });
-    const rows = Array.isArray(data?.runs) ? data.runs.slice(0, MAX_PRIOR_RUNS) : [];
-    return rows.filter((r) => typeof r.output_text === "string" && r.output_text.length > 0).map((r) => ({ startedAt: r.started_at, output: r.output_text }));
-  } catch (err) {
-    const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
-    log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
-    return [];
-  }
-}
-function isScheduledViaKanbanEnabled() {
-  const v = process.env["AGT_SCHEDULED_VIA_KANBAN"];
-  return !(v === "0" || v?.toLowerCase() === "false");
-}
-var scheduledRunsByCode = /* @__PURE__ */ new Map();
-var claimedScheduledCards = /* @__PURE__ */ new Set();
-var completedScheduledCards = /* @__PURE__ */ new Set();
-function claimScheduledCardDelivery(cardId) {
-  if (claimedScheduledCards.has(cardId)) return false;
-  claimedScheduledCards.add(cardId);
-  return true;
-}
-function releaseScheduledCardDelivery(cardId) {
-  claimedScheduledCards.delete(cardId);
-}
-function markScheduledCardDeliveryComplete(cardId) {
-  completedScheduledCards.add(cardId);
-}
-function trackScheduledRun(codeName, cardId, runId) {
-  let m = scheduledRunsByCode.get(codeName);
-  if (!m) {
-    m = /* @__PURE__ */ new Map();
-    scheduledRunsByCode.set(codeName, m);
-  }
-  m.set(cardId, runId);
-}
-function isScheduledCardTracked(cardId) {
-  for (const m of scheduledRunsByCode.values()) {
-    if (m.has(cardId)) return true;
-  }
-  return false;
-}
-function closeScheduledRunsForCode(codeName, outcome, reason) {
-  const m = scheduledRunsByCode.get(codeName);
-  if (!m || m.size === 0) return;
-  scheduledRunsByCode.delete(codeName);
-  for (const runId of m.values()) {
-    void finishRun(runId, outcome, { outcomeMessage: reason });
-  }
-}
-async function deliverScheduledCardResult(codeName, agentId, cardId) {
-  if (!claimScheduledCardDelivery(cardId)) {
-    return completedScheduledCards.has(cardId) ? "terminal" : "in_flight";
-  }
-  let card;
-  try {
-    const resp = await api.post("/host/kanban-item", {
-      agent_id: agentId,
-      item_id: cardId
-    });
-    card = resp.item;
-  } catch (err) {
-    if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
-      log(`[scheduled-kanban] delivery: card ${cardId} on '${codeName}' fetch returned ${err.status} (${err.message}) \u2014 treating as terminal, not retrying`);
-      markScheduledCardDeliveryComplete(cardId);
-      return "terminal";
-    }
-    releaseScheduledCardDelivery(cardId);
-    log(`[scheduled-kanban] delivery fetch failed for card ${cardId} on '${codeName}': ${err.message} \u2014 will retry`);
-    return "retry";
-  }
-  if (!card || card.status !== "done" || card.source_type !== "scheduled_task" || !card.source_ref) {
-    markScheduledCardDeliveryComplete(cardId);
-    return "terminal";
-  }
-  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);
-    return "terminal";
-  }
-  if (!isPlainScheduledTemplate(task.templateId)) {
-    log(`[scheduled-kanban] delivery: card ${cardId} template '${task.templateId}' on '${codeName}' is not a plain scheduled template \u2014 skipping manager delivery`);
-    markScheduledCardDeliveryComplete(cardId);
-    return "terminal";
-  }
-  const deliveryPolicy = task.deliveryPolicy ?? "always";
-  if (deliveryPolicy === "never" || deliveryPolicy === "conditional" && card.suppress_delivery !== false) {
-    log(
-      `[scheduled-kanban] Suppressed by delivery_policy=${deliveryPolicy} for card ${cardId} (task '${task.name}') on '${codeName}' \u2014 result recorded on the card only (tombstone)`
-    );
-    if (task.deliveryMode === "announce" && task.deliveryTo) {
-      await reportDeliveryStatus(agentId, task.taskId, {
-        status: "skipped",
-        error_code: "SUPPRESSED_BY_POLICY"
-      });
-    }
-    markScheduledCardDeliveryComplete(cardId);
-    return "delivered";
+    markScheduledCardDeliveryComplete(cardId);
+    return "delivered";
   }
   if (card.suppress_delivery === true) {
     log(`[scheduled-kanban] Suppressing delivery (structured flag) for card ${cardId} (task '${task.name}') on '${codeName}' \u2014 result recorded on the card only`);
@@ -5022,6 +4958,149 @@ async function fireScheduledTaskViaKanban(codeName, agentId, task, prompt) {
   }
   return routed;
 }
+async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput, delivery) {
+  try {
+    const classification = classifyOutput(rawOutput);
+    if (classification.action === "suppress") {
+      const trimmed = (rawOutput ?? "").trim();
+      const outputHash = trimmed.length === 0 ? "empty" : createHash6("sha256").update(trimmed).digest("hex").slice(0, 12);
+      log(`[claude-scheduler] Suppressing delivery for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 output_len=${trimmed.length} output_hash=${outputHash}`);
+      if (classification.suppressedNotes) {
+        const notesHash = createHash6("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
+        log(`[claude-scheduler] Suppressed notes for '${codeName}' (task=${delivery?.taskId ?? "n/a"}) \u2014 notes_len=${classification.suppressedNotes.length} notes_hash=${notesHash}`);
+      }
+      if (delivery?.mode === "announce" && delivery.to) {
+        await reportDeliveryStatus(agentId, delivery.taskId, {
+          status: "skipped",
+          error_code: "NO_CONTENT"
+        });
+      }
+      return;
+    }
+    const output = classification.deliverable;
+    if (classification.action === "strip") {
+      log(`[claude-scheduler] Stripped '<no-delivery/>' sentinel from '${codeName}' output (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent mixed it with real content; delivering the rest.`);
+    }
+    if (STANDUP_TEMPLATES.has(templateId)) {
+      const standup = parseStandupSummary(output);
+      await api.post("/host/agent-status", {
+        agent_code_name: codeName,
+        standup,
+        current_status: "idle"
+      });
+      log(`[claude-scheduler] Standup posted for '${codeName}'`);
+    } else if (TASK_UPDATE_TEMPLATES.has(templateId)) {
+      await api.post("/host/agent-status", {
+        agent_code_name: codeName,
+        current_tasks: output.slice(0, 2e3)
+      });
+      log(`[claude-scheduler] Task update posted for '${codeName}'`);
+    } else if (PLAN_TEMPLATES.has(templateId)) {
+      const planItems = parsePlanItems(output);
+      if (planItems.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          add: planItems
+        });
+        log(`[claude-scheduler] Plan items posted for '${codeName}' (${planItems.length} items)`);
+      }
+    } else if (KANBAN_WORK_TEMPLATES.has(templateId)) {
+      const kanbanUpdates = parseKanbanUpdates(output);
+      if (kanbanUpdates.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          update: kanbanUpdates
+        });
+        log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
+      }
+    }
+    if (delivery?.mode === "announce" && delivery.to) {
+      await deliverScheduledTaskOutput(
+        codeName,
+        agentId,
+        delivery.to,
+        output.slice(0, 4e3),
+        delivery.taskId
+      );
+    }
+  } catch (err) {
+    log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
+  }
+}
+
+// src/lib/manager/scheduler/execution.ts
+import { createHash as createHash7 } from "crypto";
+import { readFileSync as readFileSync12, existsSync as existsSync7 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join14 } from "path";
+function claudePidFilePath() {
+  return join14(homedir7(), ".augmented", "manager-claude-pids.json");
+}
+var inFlightClaudePids = /* @__PURE__ */ new Map();
+function registerClaudeSpawn(record) {
+  inFlightClaudePids.set(record.pid, record);
+  try {
+    addSpawn(claudePidFilePath(), record);
+  } catch (err) {
+    log(`[drain] pid-file write failed: ${err.message}`);
+  }
+}
+function unregisterClaudeSpawn(pid) {
+  inFlightClaudePids.delete(pid);
+  try {
+    removeSpawn(claudePidFilePath(), pid);
+  } catch {
+  }
+}
+async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
+  const codeName = agent.code_name;
+  const stableTasksHash = createHash7("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash7("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+  const resolvedModels = resolveModelChain(refreshData);
+  const modelsHash = createHash7("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+  const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
+  const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
+  if (combinedHash !== prevHash) {
+    const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
+    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 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;
+    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
+      const updated = markTaskFired(codeName, task.taskId, "ok");
+      claudeSchedulerStates.set(codeName, updated);
+      continue;
+    }
+    let prompt = task.prompt;
+    if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
+      const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
+      const boardPrefix = formatBoardForPrompt(boardItems, template);
+      prompt = boardPrefix + prompt;
+    }
+    inFlightClaudeTasks.add(task.taskId);
+    claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
+    if (isScheduledViaKanbanEnabled() && isPlainScheduledTemplate(task.templateId)) {
+      await fireScheduledTaskViaKanban(codeName, agent.agent_id, task, prompt);
+      inFlightClaudeTasks.delete(task.taskId);
+      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+      continue;
+    }
+    log(`[claude-scheduler] Firing '${task.name}' for '${codeName}'`);
+    executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).finally(() => {
+      inFlightClaudeTasks.delete(task.taskId);
+      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+    });
+  }
+}
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
   const mcpConfigPath = join14(projectDir, ".mcp.json");
@@ -5159,75 +5238,6 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
     claudeSchedulerStates.set(codeName, updated);
   }
 }
-async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput, delivery) {
-  try {
-    const classification = classifyOutput(rawOutput);
-    if (classification.action === "suppress") {
-      const trimmed = (rawOutput ?? "").trim();
-      const outputHash = trimmed.length === 0 ? "empty" : createHash5("sha256").update(trimmed).digest("hex").slice(0, 12);
-      log(`[claude-scheduler] Suppressing delivery for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 output_len=${trimmed.length} output_hash=${outputHash}`);
-      if (classification.suppressedNotes) {
-        const notesHash = createHash5("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
-        log(`[claude-scheduler] Suppressed notes for '${codeName}' (task=${delivery?.taskId ?? "n/a"}) \u2014 notes_len=${classification.suppressedNotes.length} notes_hash=${notesHash}`);
-      }
-      if (delivery?.mode === "announce" && delivery.to) {
-        await reportDeliveryStatus(agentId, delivery.taskId, {
-          status: "skipped",
-          error_code: "NO_CONTENT"
-        });
-      }
-      return;
-    }
-    const output = classification.deliverable;
-    if (classification.action === "strip") {
-      log(`[claude-scheduler] Stripped '<no-delivery/>' sentinel from '${codeName}' output (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent mixed it with real content; delivering the rest.`);
-    }
-    if (STANDUP_TEMPLATES.has(templateId)) {
-      const standup = parseStandupSummary(output);
-      await api.post("/host/agent-status", {
-        agent_code_name: codeName,
-        standup,
-        current_status: "idle"
-      });
-      log(`[claude-scheduler] Standup posted for '${codeName}'`);
-    } else if (TASK_UPDATE_TEMPLATES.has(templateId)) {
-      await api.post("/host/agent-status", {
-        agent_code_name: codeName,
-        current_tasks: output.slice(0, 2e3)
-      });
-      log(`[claude-scheduler] Task update posted for '${codeName}'`);
-    } else if (PLAN_TEMPLATES.has(templateId)) {
-      const planItems = parsePlanItems(output);
-      if (planItems.length > 0) {
-        await api.post("/host/kanban", {
-          agent_id: agentId,
-          add: planItems
-        });
-        log(`[claude-scheduler] Plan items posted for '${codeName}' (${planItems.length} items)`);
-      }
-    } else if (KANBAN_WORK_TEMPLATES.has(templateId)) {
-      const kanbanUpdates = parseKanbanUpdates(output);
-      if (kanbanUpdates.length > 0) {
-        await api.post("/host/kanban", {
-          agent_id: agentId,
-          update: kanbanUpdates
-        });
-        log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
-      }
-    }
-    if (delivery?.mode === "announce" && delivery.to) {
-      await deliverScheduledTaskOutput(
-        codeName,
-        agentId,
-        delivery.to,
-        output.slice(0, 4e3),
-        delivery.taskId
-      );
-    }
-  } catch (err) {
-    log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
-  }
-}
 
 // src/lib/wedge-detection.ts
 var DEFAULTS = {
@@ -6438,7 +6448,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
     const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
-    return createHash6("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    return createHash8("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
@@ -6797,7 +6807,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.37" : "dev";
+var agtCliVersion = true ? "0.28.38" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -7936,7 +7946,7 @@ async function pollCycle() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash6("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash8("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state6.agents.some(
@@ -9021,7 +9031,7 @@ async function processAgent(agent, agentStates) {
           const sessionModeForHash = refreshData.agent.session_mode;
           const senderPolicyForHash = refreshData.sender_policy ?? null;
           const CHANNEL_WRITE_VERSION = 9;
-          const configHash = createHash6("sha256").update(
+          const configHash = createHash8("sha256").update(
             canonicalJson({
               writeVersion: CHANNEL_WRITE_VERSION,
               config: entry.config,
@@ -9135,7 +9145,7 @@ async function processAgent(agent, agentStates) {
   if (channelConfigConverged) {
     const hasSenderPolicyChannel = currentChannelIds.has("slack") || currentChannelIds.has("msteams");
     const senderPolicyForRestartHash = refreshData.sender_policy ?? null;
-    const senderPolicyHash = createHash6("sha256").update(canonicalJson({ senderPolicy: senderPolicyForRestartHash })).digest("hex");
+    const senderPolicyHash = createHash8("sha256").update(canonicalJson({ senderPolicy: senderPolicyForRestartHash })).digest("hex");
     const prevSenderPolicyHash = agentState.knownSenderPolicyHashes.get(agent.agent_id);
     const senderPolicyDecision = hasSenderPolicyChannel ? decideSenderPolicyRestart({
       previousHash: prevSenderPolicyHash,
@@ -9177,7 +9187,7 @@ async function processAgent(agent, agentStates) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash6("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash8("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const behaviourDecision = decideSenderPolicyRestart({
         previousHash: prevBehaviourHash,
@@ -9224,7 +9234,7 @@ async function processAgent(agent, agentStates) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash6("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash8("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourDecision = decideSenderPolicyRestart({
         previousHash: prevSlackBehaviourHash,
@@ -9468,10 +9478,10 @@ async function processAgent(agent, agentStates) {
           desiredEntries.push({ serverId, url, headers: mcpHeaders, name: tk.toolkit_name });
         }
         const hashBasis = desiredEntries.slice().sort((a, b) => a.serverId.localeCompare(b.serverId)).map((e) => {
-          const headersHash = createHash6("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash8("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash6("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash8("sha256").update(hashBasis).digest("hex").slice(0, 16);
         const prevMcpHash = agentState.knownManagedMcpHashes.get(agent.agent_id);
         const structureHash = managedMcpStructureHash(desiredEntries);
         const prevStructureHash = agentState.knownManagedMcpStructure.get(agent.agent_id);
@@ -9486,7 +9496,7 @@ async function processAgent(agent, agentStates) {
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
-            const urlHash = createHash6("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash8("sha256").update(e.url).digest("hex").slice(0, 12);
             log(`[managed-toolkit] ${agent.code_name}: wrote '${e.name}' (serverId=${e.serverId}, url_hash=${urlHash})`);
           }
           if (frameworkAdapter.removeMcpServer && frameworkAdapter.getMcpPath) {
@@ -9620,7 +9630,7 @@ async function processAgent(agent, agentStates) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash7 } = await import("crypto");
+      const { createHash: createHash9 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -9649,7 +9659,7 @@ async function processAgent(agent, agentStates) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash7("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash9("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           const hashKey = `plugin-skill:${agent.agent_id}:${integrationSkillId}`;
           if (agentState.knownSkillHashes.get(hashKey) === contentHash) continue;
           frameworkAdapter.installSkillFiles(agent.code_name, integrationSkillId, bundle.files);
@@ -9708,7 +9718,7 @@ async function processAgent(agent, agentStates) {
         const plan = planGlobalSkillSync(
           refreshAny.global_skills ?? [],
           agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
-          (content) => createHash7("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash9("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`)
         );
         for (const { skillId, content, hash } of plan.installs) {
@@ -9752,7 +9762,7 @@ async function processAgent(agent, agentStates) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash7("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash9("sha256").update(hook.script).digest("hex").slice(0, 12);
             const hookKey = `${agent.agent_id}:${frameworkAdapter.id}:plugin-hook:${slug}:on_install`;
             if (agentState.knownSkillHashes.get(hookKey) === scriptHash) continue;
             const result = await frameworkAdapter.executePluginHook({
@@ -9767,9 +9777,9 @@ async function processAgent(agent, agentStates) {
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
             } else {
-              const stderrHash = createHash7("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash9("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash7("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash9("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
               log(
                 `Integration hook on_install '${slug}' exited ${result.exitCode} for '${agent.code_name}' ` + (missingCmdHash ? `[missing_command_hash=${missingCmdHash}] ` : "") + `[stderr_hash=${stderrHash} stderr_len=${result.stderr.length}]`
               );
@@ -10038,10 +10048,10 @@ async function processAgent(agent, agentStates) {
   } else if (agentFw === "claude-code" && tasks.length > 0) {
     await syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData);
   } else if (frameworkAdapter.syncScheduledTasks && gatewayRunning && gatewayPort) {
-    const stableTasksHash = createHash6("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-    const boardHash = boardItems.length > 0 ? createHash6("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+    const stableTasksHash = createHash8("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+    const boardHash = boardItems.length > 0 ? createHash8("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
     const resolvedModels = resolveModelChain(refreshData);
-    const modelsHash = createHash6("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+    const modelsHash = createHash8("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
     const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
     const prevTasksHash = agentState.knownTasksHashes.get(agent.agent_id);
     if (combinedHash !== prevTasksHash) {
@@ -10532,7 +10542,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       const ctx = getLastFailureContext(codeName);
       const recovery = prepareForRespawn(codeName);
       const tailSummary = !ctx.tail ? "" : KNOWN_SAFE_TAIL_SIGNATURES.has(ctx.signature) ? `; last pane output (${PANE_TAIL_PREVIEW_LINES} of ~20 lines):
-${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash6("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash8("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
       const sigSummary = ctx.signature !== "unknown" ? `; signature=${ctx.signature}` : "";
       const recoverySummary = recovery ? `; recovery=${recovery}` : "";
       log(
@@ -10546,7 +10556,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash6("sha256").
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash6("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash8("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -10625,7 +10635,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash6("sha256").
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash6("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash8("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (stableTasksHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
@@ -11151,7 +11161,7 @@ ${escapeXml(msg.content)}
     log(`[direct-chat] Reply sent for '${agent.codeName}'`);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
-    const errorId = createHash6("sha256").update(errMsg).digest("hex").slice(0, 12);
+    const errorId = createHash8("sha256").update(errMsg).digest("hex").slice(0, 12);
     log(`[direct-chat] Failed to process message for '${agent.codeName}': error_id=${errorId} error=${errMsg.slice(0, 500)}`);
     try {
       await api.post("/host/direct-chat/reply", {
@@ -11707,7 +11717,7 @@ async function syncMemories(agent, configDir, log2) {
       if (!file.endsWith(".md")) continue;
       try {
         const raw = readFileSync14(join16(memoryDir, file), "utf-8");
-        const fileHash = createHash6("sha256").update(raw).digest("hex").slice(0, 16);
+        const fileHash = createHash8("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
         const parsed = parseMemoryFile(raw, file.replace(/\.md$/, ""));
@@ -11745,14 +11755,14 @@ async function syncMemories(agent, configDir, log2) {
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
   const localFiles = existsSync9(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash6("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localListHash = createHash8("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
   try {
     const dbMemories = await api.post("/host/memories", {
       agent_id: agent.agent_id
     });
-    const responseHash = createHash6("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
+    const responseHash = createHash8("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return true;
     }
@@ -11791,7 +11801,7 @@ ${mem.content}
       }
       if (written > 0 || overwritten > 0) {
         const updatedFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash6("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        lastLocalFileHash.set(agent.agent_id, createHash8("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -12228,7 +12238,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync9(p)) return null;
-      return createHash6("sha256").update(readFileSync14(p)).digest("hex");
+      return createHash8("sha256").update(readFileSync14(p)).digest("hex");
     } catch {
       return null;
     }