@integrity-labs/agt-cli 0.28.342 → 0.28.343

package/dist/lib/manager-worker.js

@@ -46,14 +46,14 @@ import {
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-V2FVNWF2.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";
@@ -6712,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,
@@ -8122,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;
   }
@@ -8468,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.342" : "dev";
+var agtCliVersion = true ? "0.28.343" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9562,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(
@@ -9720,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()) {
@@ -10982,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({
@@ -11038,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({
@@ -11388,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);
@@ -11406,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) {
@@ -11515,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();
@@ -11544,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);
@@ -11611,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 }
         );
@@ -11662,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({
@@ -11677,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}]`
               );
@@ -11983,6 +12075,9 @@ async function processAgent(agent, agentStates) {
         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);
   }
@@ -12448,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(
@@ -12462,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,
@@ -12611,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));
@@ -13550,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,
@@ -13639,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$/, ""));
@@ -13677,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;
     }
@@ -13723,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`);
       }
     }
@@ -14139,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;
     }