@integrity-labs/agt-cli 0.28.341 → 0.28.343

package/dist/lib/manager-worker.js

@@ -46,14 +46,14 @@ import {
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-SRRZO75K.js";
+} from "../chunk-GAYSFNTX.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
   loadSchedulerState,
   markTaskFired,
   syncTasksToScheduler
-} from "../chunk-I3YS5WFV.js";
+} from "../chunk-EP6E6CIY.js";
 import {
   AnchorSessionClient,
   CONVERSATION_FAILURE_CATEGORIES,
@@ -141,7 +141,7 @@ import {
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync12, rmSync as rmSync4, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
 import { join as join21, dirname as dirname6 } from "path";
@@ -6354,11 +6354,15 @@ function resolveSlackIngestParamsFromEnv(env, ctx) {
   const appToken = env["SLACK_APP_TOKEN"];
   const botToken = env["SLACK_BOT_TOKEN"];
   if (!appToken || !botToken) return null;
+  const ackReaction = (env["SLACK_ACK_REACTION"] ?? "").trim() || void 0;
+  const skipReaction = (env["SLACK_SKIP_REACTION"] ?? "").trim() || void 0;
   return {
     appToken,
     botToken,
     senderPolicy: buildSlackSenderPolicyFromEnv(env, ctx),
-    peerConfig: buildSlackPeerClassifierConfigFromEnv(env)
+    peerConfig: buildSlackPeerClassifierConfigFromEnv(env),
+    ...ackReaction ? { ackReaction } : {},
+    ...skipReaction ? { skipReaction } : {}
   };
 }
 var BoundedSet = class {
@@ -6396,6 +6400,12 @@ async function dispatchSlackInbound(event, ctx) {
     ctx.log(`[slack-ingest:${ctx.codeName}] dropped ${redact(event.channel)} reason=${decision.reason}`);
     return "dropped_gate";
   }
+  let ackReactionInFlight = Promise.resolve();
+  if (ctx.ackReaction && event.channel && event.ts) {
+    ackReactionInFlight = ctx.addReaction({ channel: event.channel, timestamp: event.ts, name: ctx.ackReaction });
+    ackReactionInFlight.catch(() => {
+    });
+  }
   const conversationKey = `${event.channel ?? "nochannel"}:${event.thread_ts ?? event.ts ?? ""}`;
   const meta = {
     source: "slack",
@@ -6423,6 +6433,23 @@ async function dispatchSlackInbound(event, ctx) {
     });
     return "admitted_replied";
   }
+  if (ctx.skipReaction && event.channel && event.ts) {
+    const channel = event.channel;
+    const timestamp = event.ts;
+    const { ackReaction, skipReaction } = ctx;
+    if (ackReaction !== skipReaction) {
+      void (async () => {
+        try {
+          if (ackReaction) {
+            await ackReactionInFlight;
+            await ctx.removeReaction({ channel, timestamp, name: ackReaction });
+          }
+          await ctx.addReaction({ channel, timestamp, name: skipReaction });
+        } catch {
+        }
+      })();
+    }
+  }
   return "admitted_no_reply";
 }
 function redact(id) {
@@ -6448,6 +6475,46 @@ function defaultSendReply(botToken, fetchImpl, log2) {
     }
   };
 }
+function defaultAddReaction(botToken, fetchImpl, log2) {
+  return async ({ channel, timestamp, name }) => {
+    try {
+      const res = await fetchImpl(`${SLACK_API}/reactions.add`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${botToken}`,
+          "Content-Type": "application/json; charset=utf-8"
+        },
+        body: JSON.stringify({ channel, timestamp, name })
+      });
+      const data = await res.json();
+      if (!data.ok && data.error !== "already_reacted") {
+        log2(`[slack-ingest] reactions.add failed: ${data.error}`);
+      }
+    } catch (err) {
+      log2(`[slack-ingest] reactions.add threw: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+}
+function defaultRemoveReaction(botToken, fetchImpl, log2) {
+  return async ({ channel, timestamp, name }) => {
+    try {
+      const res = await fetchImpl(`${SLACK_API}/reactions.remove`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${botToken}`,
+          "Content-Type": "application/json; charset=utf-8"
+        },
+        body: JSON.stringify({ channel, timestamp, name })
+      });
+      const data = await res.json();
+      if (!data.ok && data.error !== "no_reaction") {
+        log2(`[slack-ingest] reactions.remove failed: ${data.error}`);
+      }
+    } catch (err) {
+      log2(`[slack-ingest] reactions.remove threw: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+}
 function startSlackIngest(config2) {
   const fetchImpl = config2.fetchImpl ?? globalThis.fetch;
   const socketFactory = config2.socketFactory ?? ((url) => {
@@ -6456,6 +6523,8 @@ function startSlackIngest(config2) {
     return new Ctor(url);
   });
   const sendReply = config2.sendReply ?? defaultSendReply(config2.botToken, fetchImpl, config2.log);
+  const addReaction = config2.addReaction ?? defaultAddReaction(config2.botToken, fetchImpl, config2.log);
+  const removeReaction = config2.removeReaction ?? defaultRemoveReaction(config2.botToken, fetchImpl, config2.log);
   const seen = new BoundedSet();
   let stopped = false;
   let ws = null;
@@ -6466,6 +6535,10 @@ function startSlackIngest(config2) {
     peerConfig: config2.peerConfig,
     inject: config2.inject,
     sendReply,
+    addReaction,
+    removeReaction,
+    ...config2.ackReaction ? { ackReaction: config2.ackReaction } : {},
+    ...config2.skipReaction ? { skipReaction: config2.skipReaction } : {},
     log: config2.log,
     seen
   };
@@ -6564,7 +6637,9 @@ function fingerprint(params) {
       appToken: params.appToken,
       botToken: params.botToken,
       senderPolicy: params.senderPolicy,
-      peerConfig: params.peerConfig
+      peerConfig: params.peerConfig,
+      ackReaction: params.ackReaction ?? null,
+      skipReaction: params.skipReaction ?? null
     })
   ).digest("hex");
 }
@@ -6618,6 +6693,8 @@ async function ensureOpencodeSlackIngest(opts) {
     peerConfig: params.peerConfig,
     inject: (msg) => injectOpencodeMessage(codeName, msg, { awaitReply: true }),
     log: log2,
+    ...params.ackReaction ? { ackReaction: params.ackReaction } : {},
+    ...params.skipReaction ? { skipReaction: params.skipReaction } : {},
     ...opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {},
     ...opts.socketFactory ? { socketFactory: opts.socketFactory } : {}
   });
@@ -6635,6 +6712,98 @@ function stopAllOpencodeSlackIngests(log2) {
   for (const codeName of [...ingests.keys()]) stopOpencodeSlackIngest(codeName, log2);
 }
 
+// src/lib/manager/opencode-scheduler.ts
+import { createHash as createHash12 } from "crypto";
+var MAX_OPENCODE_SCHED_CONCURRENCY = 2;
+var opencodeSchedulerStates = /* @__PURE__ */ new Map();
+var inFlightOpencodeTasks = /* @__PURE__ */ new Set();
+var opencodeTaskConcurrency = /* @__PURE__ */ new Map();
+var knownOpencodeTaskHashes = /* @__PURE__ */ new Map();
+function shouldDeliver(task, reply) {
+  if ((task.deliveryPolicy ?? "always") === "never") return false;
+  if (task.deliveryMode === "none") return false;
+  if (task.deliveryTo == null) return false;
+  return typeof reply === "string" && reply.trim().length > 0;
+}
+async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
+  const codeName = agent.code_name;
+  const tasksHash = createHash12("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  if (knownOpencodeTaskHashes.get(agent.agent_id) !== tasksHash) {
+    const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
+    const state8 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    opencodeSchedulerStates.set(codeName, state8);
+    knownOpencodeTaskHashes.set(agent.agent_id, tasksHash);
+    log(`[opencode-scheduler] tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
+  }
+  if (!opencodeSchedulerStates.has(codeName)) {
+    opencodeSchedulerStates.set(codeName, loadSchedulerState(codeName));
+  }
+  const state7 = opencodeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state7, inFlightOpencodeTasks);
+  if (ready.length === 0) return;
+  if (!isOpencodeSessionHealthy(codeName)) {
+    log(`[opencode-scheduler] '${codeName}' has ${ready.length} due task(s) but no healthy serve yet - deferring`);
+    return;
+  }
+  for (const task of ready) {
+    if ((opencodeTaskConcurrency.get(codeName) ?? 0) >= MAX_OPENCODE_SCHED_CONCURRENCY) break;
+    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
+      opencodeSchedulerStates.set(codeName, markTaskFired(codeName, task.taskId, "ok"));
+      continue;
+    }
+    inFlightOpencodeTasks.add(task.taskId);
+    opencodeTaskConcurrency.set(codeName, (opencodeTaskConcurrency.get(codeName) ?? 0) + 1);
+    void fireOpencodeScheduledTask(agent, task).finally(() => {
+      inFlightOpencodeTasks.delete(task.taskId);
+      opencodeTaskConcurrency.set(
+        codeName,
+        Math.max(0, (opencodeTaskConcurrency.get(codeName) ?? 1) - 1)
+      );
+    });
+  }
+}
+async function fireOpencodeScheduledTask(agent, task) {
+  const codeName = agent.code_name;
+  const conversationKey = `scheduled:${task.taskId}:${Date.now()}`;
+  try {
+    const result = await injectOpencodeMessage(
+      codeName,
+      {
+        channelId: "scheduler",
+        conversationKey,
+        senderId: "scheduler",
+        text: task.prompt,
+        meta: {
+          source: "scheduled_task",
+          task: task.name,
+          // The manager delivers the output; the agent isn't replying into a
+          // channel thread itself, so it must not try to.
+          requires_reply: "false"
+        }
+      },
+      { awaitReply: true }
+    );
+    if (result.status === "declined") {
+      log(`[opencode-scheduler] task '${task.name}' for '${codeName}' declined: ${result.reason}`);
+      return;
+    }
+    const reply = result.status === "replied" ? result.reply : null;
+    if (shouldDeliver(task, reply)) {
+      try {
+        await deliverScheduledTaskOutput(codeName, agent.agent_id, task.deliveryTo, reply, task.taskId);
+      } catch (err) {
+        log(`[opencode-scheduler] delivery failed for task '${task.name}' on '${codeName}': ${err.message}`);
+      }
+    } else if ((task.deliveryPolicy ?? "always") !== "never" && task.deliveryTo != null) {
+      log(`[opencode-scheduler] task '${task.name}' for '${codeName}' produced no output to deliver`);
+    }
+    opencodeSchedulerStates.set(codeName, markTaskFired(codeName, task.taskId, "ok"));
+  } catch (err) {
+    log(`[opencode-scheduler] task '${task.name}' for '${codeName}' failed: ${err.message}`);
+    opencodeSchedulerStates.set(codeName, markTaskFired(codeName, task.taskId, "error"));
+  }
+}
+
 // src/lib/wedge-detection.ts
 var DEFAULTS = {
   inboundWaitSeconds: 120,
@@ -8045,7 +8214,7 @@ var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
     const raw = readFileSync18(join21(projectDir, ".mcp.json"), "utf-8");
-    return createHash12("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    return createHash13("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
@@ -8391,7 +8560,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.341" : "dev";
+var agtCliVersion = true ? "0.28.343" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9485,7 +9654,7 @@ async function pollCycle() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash13("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state6.agents.some(
@@ -9643,7 +9812,7 @@ async function pollCycle() {
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
         } = await import("../responsiveness-probe-XLS2FXIX.js");
-        const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
+        const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-HYOOQV4A.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
         for (const tracked of consecutiveWedgeCycles.keys()) {
@@ -10094,6 +10263,15 @@ async function pollCycle() {
       pollDirectChatMessages(agentStates).catch((err) => {
         log(`Direct chat poll error: ${err.message}`);
       });
+    } else {
+      const opencodeAgents = agentStates.filter(
+        (a) => (agentFrameworkCache.get(a.codeName) ?? DEFAULT_FRAMEWORK) === "opencode"
+      );
+      if (opencodeAgents.length > 0) {
+        pollDirectChatMessages(opencodeAgents).catch((err) => {
+          log(`Direct chat poll error (opencode): ${err.message}`);
+        });
+      }
     }
     ensureRealtimeStarted(agentStates);
     ensureRealtimeDriftStarted(agentStates);
@@ -10896,7 +11074,7 @@ async function processAgent(agent, agentStates) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash12("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash13("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const msteamsBehaviourRestrictive = isMsTeamsBehaviourRestrictive(behaviourSubset);
       const behaviourDecision = decideSenderPolicyRestart({
@@ -10952,7 +11130,7 @@ async function processAgent(agent, agentStates) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash12("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash13("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourRestrictive = isSlackBehaviourRestrictive(slackBehaviourSubset);
       const slackBehaviourDecision = decideSenderPolicyRestart({
@@ -11302,10 +11480,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 = createHash12("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash13("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash12("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash13("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);
@@ -11320,7 +11498,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 = createHash12("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash13("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) {
@@ -11429,7 +11607,7 @@ async function processAgent(agent, agentStates) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash13 } = await import("crypto");
+      const { createHash: createHash14 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -11458,7 +11636,7 @@ async function processAgent(agent, agentStates) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash13("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash14("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);
@@ -11525,7 +11703,7 @@ async function processAgent(agent, agentStates) {
         const plan = planGlobalSkillSync(
           [...globalSkillsPayload ?? [], ...sharedSkillsPayload ?? []],
           prevIds,
-          (content) => createHash13("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash14("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`),
           { desiredResolved }
         );
@@ -11576,7 +11754,7 @@ async function processAgent(agent, agentStates) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash13("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash14("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({
@@ -11591,9 +11769,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 = createHash13("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash14("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash13("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash14("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}]`
               );
@@ -11701,7 +11879,7 @@ async function processAgent(agent, agentStates) {
       }
     }
   }
-  if (agentFw === "claude-code" && sessionMode === "persistent") {
+  if (agentFw === "claude-code" && sessionMode === "persistent" || agentFw === "opencode") {
     const wasSessionHealthy = isSessionHealthy(agent.code_name);
     let psResult;
     try {
@@ -11733,167 +11911,172 @@ async function processAgent(agent, agentStates) {
     } else if (stuck.recovered) {
       log(`[persistent-session-stuck] agent=${agent.code_name} recovered from stuck state`);
     }
-    try {
-      checkMcpConfigDriftAndScheduleRestart(agent.code_name, getProjectDir(agent.code_name));
-    } catch (err) {
-      log(`[hot-reload] .mcp.json drift check failed for '${agent.code_name}': ${err.message}`);
-    }
-    if (channelConfigConverged) {
+    if (agentFw === "claude-code") {
       try {
-        checkChannelSecretDriftAndScheduleRestart(agent.code_name, getProjectDir(agent.code_name));
+        checkMcpConfigDriftAndScheduleRestart(agent.code_name, getProjectDir(agent.code_name));
       } catch (err) {
-        log(`[hot-reload] channel-secret drift check failed for '${agent.code_name}': ${err.message}`);
+        log(`[hot-reload] .mcp.json drift check failed for '${agent.code_name}': ${err.message}`);
       }
-    }
-    try {
-      const sess = getSessionState(agent.code_name);
-      let mcpJsonParsed = null;
-      try {
-        const mcpPath = join21(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync18(mcpPath, "utf-8"));
-      } catch {
+      if (channelConfigConverged) {
+        try {
+          checkChannelSecretDriftAndScheduleRestart(agent.code_name, getProjectDir(agent.code_name));
+        } catch (err) {
+          log(`[hot-reload] channel-secret drift check failed for '${agent.code_name}': ${err.message}`);
+        }
       }
-      reapMissingMcpSessions({
-        log,
-        codeName: agent.code_name,
-        mcpJson: mcpJsonParsed,
-        sessionStartedAt: sess?.startedAt ?? null,
-        // ENG-6660: under Docker the MCP children live in the agent's container
-        // PID namespace - probe inside it (docker exec ps) instead of the host,
-        // or every declared MCP looks "missing" -> restart loop -> flapping.
-        isolated: isolationMode(agent.code_name) === "docker",
-        // ENG-6486: a restart is already scheduled/deferred for this agent (e.g.
-        // a freshly-added channel awaiting its convergence restart, deferred by
-        // the maintenance window). The pending restart will spawn the declared-
-        // but-not-yet-live MCP, so don't let the reaper re-fire + inflate the
-        // McpReaperRestartsHourly metric into a false flapping alarm.
-        restartPending: pendingSessionRestarts.has(agent.code_name),
-        // ENG-5441 / ENG-5547: a mcp-presence-reaper restart counts against
-        // the agent-wide breaker ONLY when several distinct MCP servers are
-        // missing at once — a thrashing collection that rotates restarts of
-        // the whole session, which the per-MCP cap can't see. A restart
-        // driven by a SINGLE persistently-failing server is left to that
-        // server's own ENG-5279 give-up cap (→ marked unhealthy via onGiveUp
-        // → dropped from the next .mcp.json), so one bad integration is
-        // isolated and the agent keeps running degraded instead of being
-        // paused wholesale. reaperRestartBreakerReason() encodes that
-        // single-vs-multi decision; undefined means "restart, don't count".
-        //
-        // ENG-6264: the breaker-count reason (above, undefined for a single dead
-        // MCP) is decoupled from the GATE reason. Pre-6264 an undefined breaker
-        // reason also made the restart non-gateable → 'bypass' → the session was
-        // torn down mid-turn (the common single-MCP case interrupted busy
-        // agents). Always pass 'mcp-presence-reaper' as the gate reason so the
-        // restart defers-until-idle, while breakerReason still governs whether it
-        // counts against the breaker.
-        stopSession: (codeName, ctx) => stopPersistentSessionAndForgetMcpBaseline(
-          codeName,
-          reaperRestartBreakerReason(ctx.activeKeys),
-          "mcp-presence-reaper"
-        ),
-        // ENG-5292: when the reaper gives up on a managed MCP (cap from
-        // ENG-5279 + state-preservation from ENG-5285 both said "this
-        // MCP keeps failing after 3 restart cycles"), mark the matching
-        // integration unhealthy server-side. The next /host/managed-
-        // toolkits poll drops it from the response → next writeMcpServer
-        // omits it → broken MCP is cleanly gone instead of declared-but-
-        // dead.
-        //
-        // Async fire-and-forget — the reaper's correctness must not
-        // depend on the API call succeeding. Errors are caught inside
-        // the .then/.catch chain and logged.
-        onGiveUp: (codeName, serverKey) => {
-          const mapping = managedToolkitIdByAgentAndServerId.get(
-            managedToolkitMapKey(agent.agent_id, serverKey)
-          );
-          if (!mapping) {
-            log(
-              `[mcp-presence-reaper] give-up on '${codeName}:${serverKey}' \u2014 not a managed toolkit (no toolkit_id mapping), skipping integration-health API call`
-            );
-            return;
-          }
-          const { toolkitId, connectionKey } = mapping;
-          const agentId = agent.agent_id;
-          api.post("/host/integration-health", {
-            agent_id: agentId,
-            toolkit_id: toolkitId,
-            // ENG-7543: scope the mark-unhealthy to the specific connection whose
-            // MCP server gave up, so a dead 2nd mailbox doesn't disable the first.
-            connection_key: connectionKey,
-            action: "mark_unhealthy",
-            reason: `mcp-presence-reaper cap (${3} consecutive failed restart cycles) tripped on '${serverKey}'`
-          }).then((res) => {
-            log(
-              `[mcp-presence-reaper] marked integration unhealthy for '${codeName}' toolkit '${toolkitId}' (ENG-5292): ${JSON.stringify(res).slice(0, 200)}`
-            );
-          }).catch((err) => {
-            log(
-              `[mcp-presence-reaper] failed to mark integration unhealthy for '${codeName}' toolkit '${toolkitId}' (ENG-5292): ${err.message} \u2014 local give-up state still recorded; will retry on next agent provisioning cycle if .mcp.json changes`
-            );
-          });
-        },
-        // ENG-5286: record the restart event with the API so the
-        // agent-heartbeat-monitor cron can aggregate per-agent counts
-        // into the McpReaperRestartsHourly CloudWatch metric. Fire-and-
-        // forget — the reaper's correctness must not depend on this.
-        onRestart: (codeName, { activeKeys, givenUpKeys }) => {
-          api.post("/host/mcp-reaper-restart", {
-            agent_id: agent.agent_id,
-            code_name: codeName,
-            server_keys: activeKeys,
-            given_up_keys: givenUpKeys
-          }).catch((err) => {
-            log(
-              `[mcp-presence-reaper] failed to record restart event for '${codeName}' (ENG-5286): ${err.message} \u2014 local restart still proceeded; CloudWatch metric will under-count this event`
-            );
-          });
-          void reportReaperEvent(
-            agent.agent_id,
-            "mcp-presence-reaper",
-            "restart",
-            givenUpKeys.length > 0 ? `restarted session; MCP server(s) still down after restart budget: ${givenUpKeys.join(", ")}` : `restarted session to recover MCP server(s): ${activeKeys.join(", ")}`
-          );
-        },
-        // ENG-5932: classify each declared key for the quarantine path. Reads a
-        // server-declared criticality field off the .mcp.json entry when
-        // present (Slice 2 will stamp it); otherwise fails closed to ESSENTIAL
-        // for everything except the known optional channel set. Tool servers
-        // (composio_*/xero) classify ESSENTIAL here and stay on the existing
-        // managed-toolkit onGiveUp path above.
-        classifyKey: (serverKey) => classifyChannelCriticality(
-          serverKey,
-          mcpJsonParsed?.mcpServers?.[serverKey]
-        ),
-        quarantineDwellMs: channelQuarantineDwellMs(),
-        quarantineMode: channelQuarantineMode(),
-        // ENG-5932: enforce-mode quarantine. Persist the local marker; the next
-        // provisioning poll then omits the channel from .mcp.json + the launch
-        // flags, and the channel-set-change / .mcp.json-drift restart paths are
-        // taught to NOT bounce the session for a quarantine-driven removal.
-        // Local-authoritative: no API call — with the control plane down, the
-        // flap still stops.
-        onQuarantine: (codeName, serverKey) => {
-          const newly = channelQuarantineStore().quarantine(
+      try {
+        const sess = getSessionState(agent.code_name);
+        let mcpJsonParsed = null;
+        try {
+          const mcpPath = join21(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync18(mcpPath, "utf-8"));
+        } catch {
+        }
+        reapMissingMcpSessions({
+          log,
+          codeName: agent.code_name,
+          mcpJson: mcpJsonParsed,
+          sessionStartedAt: sess?.startedAt ?? null,
+          // ENG-6660: under Docker the MCP children live in the agent's container
+          // PID namespace - probe inside it (docker exec ps) instead of the host,
+          // or every declared MCP looks "missing" -> restart loop -> flapping.
+          isolated: isolationMode(agent.code_name) === "docker",
+          // ENG-6486: a restart is already scheduled/deferred for this agent (e.g.
+          // a freshly-added channel awaiting its convergence restart, deferred by
+          // the maintenance window). The pending restart will spawn the declared-
+          // but-not-yet-live MCP, so don't let the reaper re-fire + inflate the
+          // McpReaperRestartsHourly metric into a false flapping alarm.
+          restartPending: pendingSessionRestarts.has(agent.code_name),
+          // ENG-5441 / ENG-5547: a mcp-presence-reaper restart counts against
+          // the agent-wide breaker ONLY when several distinct MCP servers are
+          // missing at once — a thrashing collection that rotates restarts of
+          // the whole session, which the per-MCP cap can't see. A restart
+          // driven by a SINGLE persistently-failing server is left to that
+          // server's own ENG-5279 give-up cap (→ marked unhealthy via onGiveUp
+          // → dropped from the next .mcp.json), so one bad integration is
+          // isolated and the agent keeps running degraded instead of being
+          // paused wholesale. reaperRestartBreakerReason() encodes that
+          // single-vs-multi decision; undefined means "restart, don't count".
+          //
+          // ENG-6264: the breaker-count reason (above, undefined for a single dead
+          // MCP) is decoupled from the GATE reason. Pre-6264 an undefined breaker
+          // reason also made the restart non-gateable → 'bypass' → the session was
+          // torn down mid-turn (the common single-MCP case interrupted busy
+          // agents). Always pass 'mcp-presence-reaper' as the gate reason so the
+          // restart defers-until-idle, while breakerReason still governs whether it
+          // counts against the breaker.
+          stopSession: (codeName, ctx) => stopPersistentSessionAndForgetMcpBaseline(
             codeName,
-            serverKey,
-            `mcp-presence-reaper: optional channel dead past restart budget + dwell`,
-            Date.now()
-          );
-          if (newly) {
-            log(
-              `[channel-quarantine] persisted quarantine marker for '${codeName}:${serverKey}' \u2014 will be dropped from .mcp.json on next provisioning poll (ENG-5932)`
+            reaperRestartBreakerReason(ctx.activeKeys),
+            "mcp-presence-reaper"
+          ),
+          // ENG-5292: when the reaper gives up on a managed MCP (cap from
+          // ENG-5279 + state-preservation from ENG-5285 both said "this
+          // MCP keeps failing after 3 restart cycles"), mark the matching
+          // integration unhealthy server-side. The next /host/managed-
+          // toolkits poll drops it from the response → next writeMcpServer
+          // omits it → broken MCP is cleanly gone instead of declared-but-
+          // dead.
+          //
+          // Async fire-and-forget — the reaper's correctness must not
+          // depend on the API call succeeding. Errors are caught inside
+          // the .then/.catch chain and logged.
+          onGiveUp: (codeName, serverKey) => {
+            const mapping = managedToolkitIdByAgentAndServerId.get(
+              managedToolkitMapKey(agent.agent_id, serverKey)
             );
+            if (!mapping) {
+              log(
+                `[mcp-presence-reaper] give-up on '${codeName}:${serverKey}' \u2014 not a managed toolkit (no toolkit_id mapping), skipping integration-health API call`
+              );
+              return;
+            }
+            const { toolkitId, connectionKey } = mapping;
+            const agentId = agent.agent_id;
+            api.post("/host/integration-health", {
+              agent_id: agentId,
+              toolkit_id: toolkitId,
+              // ENG-7543: scope the mark-unhealthy to the specific connection whose
+              // MCP server gave up, so a dead 2nd mailbox doesn't disable the first.
+              connection_key: connectionKey,
+              action: "mark_unhealthy",
+              reason: `mcp-presence-reaper cap (${3} consecutive failed restart cycles) tripped on '${serverKey}'`
+            }).then((res) => {
+              log(
+                `[mcp-presence-reaper] marked integration unhealthy for '${codeName}' toolkit '${toolkitId}' (ENG-5292): ${JSON.stringify(res).slice(0, 200)}`
+              );
+            }).catch((err) => {
+              log(
+                `[mcp-presence-reaper] failed to mark integration unhealthy for '${codeName}' toolkit '${toolkitId}' (ENG-5292): ${err.message} \u2014 local give-up state still recorded; will retry on next agent provisioning cycle if .mcp.json changes`
+              );
+            });
+          },
+          // ENG-5286: record the restart event with the API so the
+          // agent-heartbeat-monitor cron can aggregate per-agent counts
+          // into the McpReaperRestartsHourly CloudWatch metric. Fire-and-
+          // forget — the reaper's correctness must not depend on this.
+          onRestart: (codeName, { activeKeys, givenUpKeys }) => {
+            api.post("/host/mcp-reaper-restart", {
+              agent_id: agent.agent_id,
+              code_name: codeName,
+              server_keys: activeKeys,
+              given_up_keys: givenUpKeys
+            }).catch((err) => {
+              log(
+                `[mcp-presence-reaper] failed to record restart event for '${codeName}' (ENG-5286): ${err.message} \u2014 local restart still proceeded; CloudWatch metric will under-count this event`
+              );
+            });
             void reportReaperEvent(
               agent.agent_id,
               "mcp-presence-reaper",
-              "quarantine",
-              `optional channel '${serverKey}' dead past restart budget + dwell \u2014 quarantined`
+              "restart",
+              givenUpKeys.length > 0 ? `restarted session; MCP server(s) still down after restart budget: ${givenUpKeys.join(", ")}` : `restarted session to recover MCP server(s): ${activeKeys.join(", ")}`
+            );
+          },
+          // ENG-5932: classify each declared key for the quarantine path. Reads a
+          // server-declared criticality field off the .mcp.json entry when
+          // present (Slice 2 will stamp it); otherwise fails closed to ESSENTIAL
+          // for everything except the known optional channel set. Tool servers
+          // (composio_*/xero) classify ESSENTIAL here and stay on the existing
+          // managed-toolkit onGiveUp path above.
+          classifyKey: (serverKey) => classifyChannelCriticality(
+            serverKey,
+            mcpJsonParsed?.mcpServers?.[serverKey]
+          ),
+          quarantineDwellMs: channelQuarantineDwellMs(),
+          quarantineMode: channelQuarantineMode(),
+          // ENG-5932: enforce-mode quarantine. Persist the local marker; the next
+          // provisioning poll then omits the channel from .mcp.json + the launch
+          // flags, and the channel-set-change / .mcp.json-drift restart paths are
+          // taught to NOT bounce the session for a quarantine-driven removal.
+          // Local-authoritative: no API call — with the control plane down, the
+          // flap still stops.
+          onQuarantine: (codeName, serverKey) => {
+            const newly = channelQuarantineStore().quarantine(
+              codeName,
+              serverKey,
+              `mcp-presence-reaper: optional channel dead past restart budget + dwell`,
+              Date.now()
             );
+            if (newly) {
+              log(
+                `[channel-quarantine] persisted quarantine marker for '${codeName}:${serverKey}' \u2014 will be dropped from .mcp.json on next provisioning poll (ENG-5932)`
+              );
+              void reportReaperEvent(
+                agent.agent_id,
+                "mcp-presence-reaper",
+                "quarantine",
+                `optional channel '${serverKey}' dead past restart budget + dwell \u2014 quarantined`
+              );
+            }
           }
-        }
-      });
-    } catch (err) {
-      log(`[mcp-presence-reaper] presence check failed for '${agent.code_name}': ${err.message}`);
+        });
+      } catch (err) {
+        log(`[mcp-presence-reaper] presence check failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
+    if (agentFw === "opencode" && tasks.length > 0) {
+      await syncAndCheckOpencodeScheduler(agent, tasks, refreshData);
     }
   } else if (agentFw === "claude-code" && tasks.length > 0) {
     await syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData);
@@ -12161,7 +12344,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
     return { decision: "healthy", spawnAttempted: false, sessionHealthyAfter: true };
   }
   stopOpencodeSlackIngest(codeName, log);
-  const opencodeProjectDir = join21(getFramework("opencode").getAgentDir(codeName), "project");
+  const opencodeProjectDir = join21(getFramework("opencode").getAgentDir(codeName), "provision");
   const openRouterRaw = refreshData.openrouter ?? null;
   const serveEnv = {
     AGT_HOST: requireHost(),
@@ -12360,7 +12543,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:${createHash12("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash13("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(
@@ -12374,7 +12557,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash12("sha256")
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash12("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash13("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -12523,7 +12706,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash12("sha256")
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash12("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash13("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));
@@ -13462,8 +13645,15 @@ function generateArtifacts(agent, refreshData, adapter) {
   log(
     `[provision/active-tasks] agent=${agent.code_name} count=${activeTasksFromRefresh.length} estimated_tokens=${activeTasksTokens}`
   );
+  const provisionAgent = (() => {
+    const rawAgent = refreshData.agent;
+    if (rawAgent?.["framework"] !== "opencode") return rawAgent;
+    const hostOverride = process.env["AGT_OPENCODE_MODEL"]?.trim();
+    const resolved = hostOverride || resolveModelChain(refreshData).primary || rawAgent?.["primary_model"];
+    return resolved ? { ...rawAgent, primary_model: resolved } : rawAgent;
+  })();
   const provisionInput = {
-    agent: refreshData.agent,
+    agent: provisionAgent,
     charterFrontmatter,
     charterContent,
     toolsFrontmatter,
@@ -13551,7 +13741,7 @@ async function syncMemories(agent, configDir, log2) {
       if (!file.endsWith(".md")) continue;
       try {
         const raw = readFileSync18(join21(memoryDir, file), "utf-8");
-        const fileHash = createHash12("sha256").update(raw).digest("hex").slice(0, 16);
+        const fileHash = createHash13("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$/, ""));
@@ -13589,14 +13779,14 @@ async function syncMemories(agent, configDir, log2) {
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
   const localFiles = existsSync12(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash12("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localListHash = createHash13("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 = createHash12("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
+    const responseHash = createHash13("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return true;
     }
@@ -13635,7 +13825,7 @@ ${mem.content}
       }
       if (written > 0 || overwritten > 0) {
         const updatedFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash12("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        lastLocalFileHash.set(agent.agent_id, createHash13("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -14051,7 +14241,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync12(p)) return null;
-      return createHash12("sha256").update(readFileSync18(p)).digest("hex");
+      return createHash13("sha256").update(readFileSync18(p)).digest("hex");
     } catch {
       return null;
     }