@integrity-labs/agt-cli 0.28.341 → 0.28.342

package/dist/lib/manager-worker.js

@@ -46,7 +46,7 @@ import {
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-SRRZO75K.js";
+} from "../chunk-V2FVNWF2.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -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 } : {}
   });
@@ -8391,7 +8468,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.342" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -10094,6 +10171,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);
@@ -11701,7 +11787,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 +11819,169 @@ 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}`);
+      }
     }
   } else if (agentFw === "claude-code" && tasks.length > 0) {
     await syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData);
@@ -12161,7 +12249,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(),