@integrity-labs/agt-cli 0.24.8 → 0.24.9

package/dist/lib/manager-worker.js

@@ -1,4 +1,5 @@
 import {
+  ApiError,
   SUPERVISOR_RESTART_EXIT_CODE,
   api,
   estimateActiveTasksTokens,
@@ -12,7 +13,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-XW27YIEU.js";
+} from "../chunk-67PAZ3I4.js";
 import {
   findTaskByTemplate,
   getProjectDir as getProjectDir2,
@@ -20,7 +21,7 @@ import {
   loadSchedulerState,
   markTaskFired,
   syncTasksToScheduler
-} from "../chunk-TS7W4YNI.js";
+} from "../chunk-HR5T2RQF.js";
 import {
   buildAllowedTools,
   ensureKanbanLoopArmed,
@@ -28,6 +29,7 @@ import {
   getProjectDir,
   getSessionState,
   injectMessage,
+  injectMessageWithStatus,
   isAgentIdle,
   isAgentPromptReady,
   isKanbanLoopArmedForCurrentSession,
@@ -48,11 +50,12 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   takeZombieDetection
-} from "../chunk-3A2PMQM4.js";
+} from "../chunk-S262PDVS.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
   attributeTranscriptUsageByRun,
+  classifyActor,
   classifyOutput,
   extractFrontmatter,
   formatActorId,
@@ -68,7 +71,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-53TCAGCM.js";
+} from "../chunk-354Z63L7.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash3 } from "crypto";
@@ -2695,6 +2698,7 @@ function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason) {
   runningMcpHashes.delete(codeName);
   runningMcpServerKeys.delete(codeName);
   closeInjectedRunIfOpen(codeName, "cancelled", `session stopped (${breakerReason ?? "deprovision"})`);
+  closeScheduledRunsForCode(codeName, "cancelled", `session stopped (${breakerReason ?? "deprovision"})`);
   if (breakerReason) {
     recordRestartForBreaker(codeName, breakerReason);
   }
@@ -2838,7 +2842,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.24.8" : "dev";
+var agtCliVersion = true ? "0.24.9" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3797,7 +3801,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-XJYOPFIP.js");
+      const { collectDiagnostics } = await import("../persistent-session-OYO4DTPL.js");
       const diagCodeNames = [...persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -3848,7 +3852,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-EWZNGMTX.js");
+      } = await import("../responsiveness-probe-SSFKGL7Q.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...persistentSessionAgents];
@@ -5106,7 +5110,9 @@ async function processAgent(agent, agentStates) {
   }
   const agentFw = agentFrameworkCache.get(agent.code_name) ?? "openclaw";
   const sessionMode = refreshData.agent.session_mode ?? "oneshot";
-  if (isKanbanHybridEnabled() && agentFw === "claude-code" && sessionMode === "persistent") {
+  const wantsHybridInject = isKanbanHybridEnabled();
+  const wantsScheduledReconcile = isScheduledViaKanbanEnabled();
+  if ((wantsHybridInject || wantsScheduledReconcile) && agentFw === "claude-code" && sessionMode === "persistent") {
     let hybridBoard = hasBoardTemplates ? boardItems : void 0;
     if (!hybridBoard) {
       try {
@@ -5120,13 +5126,14 @@ async function processAgent(agent, agentStates) {
         hybridBoard = kanbanBoardCache.get(agent.code_name) ?? [];
       }
     }
-    if (hasHybridActionableItems(hybridBoard)) {
-      const actionableCount = hybridBoard.filter(
-        (i) => HYBRID_ACTIONABLE_STATUSES.has(i.status)
-      ).length;
-      void maybeInjectKanbanCheck(agent.code_name, agent.agent_id, actionableCount);
-    } else {
-      closeInjectedRunIfOpen(agent.code_name, "completed", "kanban board drained");
+    void reconcileScheduledRuns(agent.code_name, agent.agent_id, hybridBoard);
+    if (wantsHybridInject) {
+      if (hasHybridActionableItems(hybridBoard)) {
+        const actionableCount = hybridBoard.filter(isHybridActionable).length;
+        void maybeInjectKanbanCheck(agent.code_name, agent.agent_id, actionableCount);
+      } else {
+        closeInjectedRunIfOpen(agent.code_name, "completed", "kanban board drained");
+      }
     }
   }
   if (agentFw === "claude-code" && sessionMode === "persistent") {
@@ -5757,6 +5764,157 @@ async function fetchPriorScheduledRuns(agentId, taskId) {
     return [];
   }
 }
+function isScheduledViaKanbanEnabled() {
+  const v = process.env["AGT_SCHEDULED_VIA_KANBAN"];
+  return v === "1" || v?.toLowerCase() === "true";
+}
+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 __resetScheduledDeliveryDedupeForTest() {
+  claimedScheduledCards.clear();
+  completedScheduledCards.clear();
+}
+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 state5 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state5.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";
+  }
+  await processClaudeTaskResult(codeName, agentId, task.templateId, card.result ?? "", {
+    mode: task.deliveryMode,
+    channel: task.deliveryChannel,
+    to: task.deliveryTo,
+    taskId: task.taskId
+  });
+  markScheduledCardDeliveryComplete(cardId);
+  log(`[scheduled-kanban] Delivered result from card ${cardId} (task '${task.name}') for '${codeName}'`);
+  return "delivered";
+}
+async function reconcileScheduledRuns(codeName, agentId, board) {
+  const m = scheduledRunsByCode.get(codeName);
+  if (!m || m.size === 0) return;
+  const byId = new Map(board.map((i) => [i.id, i]));
+  for (const [cardId, runId] of [...m.entries()]) {
+    const card = byId.get(cardId);
+    if (!card) continue;
+    if (card.status === "done") {
+      const result = await deliverScheduledCardResult(codeName, agentId, cardId);
+      if (result === "retry" || result === "in_flight") continue;
+      m.delete(cardId);
+      void finishRun(runId, "completed", { outcomeMessage: "scheduled-task card done" });
+    } else if (card.status === "failed") {
+      m.delete(cardId);
+      void finishRun(runId, "failed", { outcomeMessage: "scheduled-task card failed" });
+    }
+  }
+  if (m.size === 0) scheduledRunsByCode.delete(codeName);
+}
+async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt) {
+  const { run_id, kanban_item_id } = await startRun({
+    agent_id: agentId,
+    source_type: "scheduled_task",
+    source_ref: task.taskId,
+    metadata: { template_id: task.templateId, name: task.name, via: "kanban-inject" },
+    materialize_kanban: {
+      title: task.name,
+      description: prompt,
+      priority: 2,
+      initial_status: "todo"
+    }
+  });
+  if (!run_id || !kanban_item_id) {
+    log(`[scheduled-kanban] materialise incomplete for task '${task.name}' on '${codeName}' (run_id=${run_id ? "ok" : "null"}, card=${kanban_item_id ? "ok" : "null"}) \u2014 falling back to claude -p`);
+    if (run_id) void finishRun(run_id, "failed", { outcomeMessage: "kanban materialise incomplete", completeKanbanItemId: kanban_item_id });
+    return false;
+  }
+  const nudge = `You have a new scheduled task on your kanban board: id=${kanban_item_id} title=${JSON.stringify(task.name)}. Call kanban_move("${kanban_item_id}", "in_progress"), do the work described on the card, then write the finished result onto the card and mark it done. Do NOT send, post, or message the result to anyone yourself \u2014 recording it on the card is enough; delivery to the recipient is handled for you.
+` + formatRunMarker(run_id);
+  let injectStatus;
+  try {
+    injectStatus = await injectMessageWithStatus(codeName, "task", nudge, { task_name: "scheduled-task" }, log);
+  } catch (err) {
+    log(`[scheduled-kanban] nudge injection threw for task '${task.name}' on '${codeName}': ${err.message} \u2014 closing card + falling back to claude -p`);
+    void finishRun(run_id, "failed", { outcomeMessage: "scheduled-task nudge delivery threw", completeKanbanItemId: kanban_item_id });
+    return false;
+  }
+  const { delivered, fallbackUsed } = injectStatus;
+  if (!delivered && !fallbackUsed) {
+    log(`[scheduled-kanban] nudge delivery failed for task '${task.name}' on '${codeName}' \u2014 closing card + falling back to claude -p`);
+    void finishRun(run_id, "failed", { outcomeMessage: "scheduled-task nudge delivery failed", completeKanbanItemId: kanban_item_id });
+    return false;
+  }
+  if (!delivered && fallbackUsed) {
+    log(`[scheduled-kanban] nudge sent via send-keys (unverified) for task '${task.name}' on '${codeName}' \u2014 proceeding without oneshot fallback`);
+  }
+  trackScheduledRun(codeName, kanban_item_id, run_id);
+  log(`[scheduled-kanban] Routed task '${task.name}' for '${codeName}' via todo card ${kanban_item_id} run_id=${run_id}`);
+  return true;
+}
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
   const mcpConfigPath = join6(projectDir, ".mcp.json");
@@ -6264,6 +6422,31 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash3("sha256").
       }
       inFlightClaudeTasks.add(task.taskId);
       claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
+      if (isScheduledViaKanbanEnabled() && isPlainScheduledTemplate(task.templateId)) {
+        let routed = false;
+        try {
+          routed = await routeScheduledTaskViaKanban(codeName, agent.agent_id, task, prompt);
+        } catch (err) {
+          log(`[scheduled-kanban] route threw for '${task.name}' on '${codeName}': ${err.message}`);
+          routed = false;
+        }
+        if (routed) {
+          try {
+            const updated = markTaskFired(codeName, task.taskId, "ok");
+            claudeSchedulerStates.set(codeName, updated);
+          } catch (err) {
+            log(`[scheduled-kanban] markTaskFired failed for '${task.name}' on '${codeName}': ${err.message}`);
+          }
+          if (task.scheduleKind === "at") {
+            api.post("/host/schedules/disable", { agent_id: agent.agent_id, task_id: task.taskId }).catch(
+              (err) => log(`[scheduled-kanban] Failed to disable one-off task '${task.name}': ${err.message}`)
+            );
+          }
+          inFlightClaudeTasks.delete(task.taskId);
+          claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+          break;
+        }
+      }
       log(`[persistent-session] Firing task '${task.name}' for '${codeName}' via claude -p`);
       executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).catch(() => {
       }).finally(() => {
@@ -6447,6 +6630,7 @@ function ensureRealtimeKanbanStarted(agentStates) {
       token: exchange.token,
       agentIds: activeAgentIds,
       onTodayItem: (item) => {
+        if (item.source_type === "scheduled_task") return;
         const agent = agentStates.find((a) => a.agentId === item.agent_id);
         if (!agent) return;
         const agentFw = agentFrameworkCache.get(agent.codeName) ?? "openclaw";
@@ -6474,6 +6658,9 @@ function ensureRealtimeKanbanStarted(agentStates) {
         log(
           `[realtime] Kanban completion forwarded for '${codeName}': item=${event.item_id} status=${event.status} actor=${event.last_actor_id ?? "unknown"}`
         );
+        if (event.status === "done" && (isScheduledViaKanbanEnabled() || isKanbanHybridEnabled()) && classifyActor(event.last_actor_id, event.agent_id) === "user" && isScheduledCardTracked(event.item_id)) {
+          void deliverScheduledCardResult(codeName, event.agent_id, event.item_id);
+        }
       },
       log
     });
@@ -6598,7 +6785,7 @@ ${escapeXml(msg.content)}
   try {
     let reply;
     if (fw === "claude-code") {
-      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-XHJS2MZV.js");
+      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-EM24LTGV.js");
       const projDir = ccProjectDir(agent.codeName);
       const mcpConfigPath = join6(projDir, ".mcp.json");
       const serverNames = [];
@@ -6692,6 +6879,9 @@ var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-su
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
 var KANBAN_WORK_TEMPLATES = /* @__PURE__ */ new Set(["kanban-work"]);
+function isPlainScheduledTemplate(templateId) {
+  return !STANDUP_TEMPLATES.has(templateId) && !TASK_UPDATE_TEMPLATES.has(templateId) && !PLAN_TEMPLATES.has(templateId) && !KANBAN_WORK_TEMPLATES.has(templateId);
+}
 function isKanbanWorkCronDisabled() {
   const v = process.env["AGT_DISABLE_KANBAN_WORK_CRON"];
   return v === "1" || v?.toLowerCase() === "true";
@@ -6705,8 +6895,11 @@ function isKanbanHybridDryRun() {
   return v === "1" || v?.toLowerCase() === "true";
 }
 var HYBRID_ACTIONABLE_STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress"]);
+function isHybridActionable(item) {
+  return HYBRID_ACTIONABLE_STATUSES.has(item.status) && item.source_type !== "scheduled_task";
+}
 function hasHybridActionableItems(items) {
-  return items.some((item) => HYBRID_ACTIONABLE_STATUSES.has(item.status));
+  return items.some(isHybridActionable);
 }
 var lastKanbanInjectAt = /* @__PURE__ */ new Map();
 var openInjectedRunByCode = /* @__PURE__ */ new Map();
@@ -6782,7 +6975,7 @@ function warnOnConflictingKanbanModes() {
   }
 }
 var BOARD_INJECT_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan", "task-update", "hourly-status", "end-of-day-summary", "kanban-work"]);
-var ACTIONABLE_STATUSES = /* @__PURE__ */ new Set(["backlog", "todo", "in_progress"]);
+var ACTIONABLE_STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress"]);
 function hasActionableItems(items) {
   return items.some((item) => ACTIONABLE_STATUSES.has(item.status));
 }
@@ -7619,7 +7812,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-4F53C7RB.js");
+  } = await import("../claude-pair-runtime-6IB35CES.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));
@@ -8188,6 +8381,9 @@ async function stopPolling(opts = {}) {
   stopCaffeinate();
   stopRealtimeChat();
   stopGatewayPool();
+  for (const codeName of [...scheduledRunsByCode.keys()]) {
+    closeScheduledRunsForCode(codeName, "cancelled", "manager shutdown");
+  }
   log("Killing tmux sessions...");
   await killAllAgtTmuxSessions();
   log("Stopping persistent sessions...");
@@ -8385,19 +8581,28 @@ process.on("disconnect", () => {
 });
 export {
   ChildProcessError,
+  __resetScheduledDeliveryDedupeForTest,
   applyRestartAcks,
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
+  deliverScheduledCardResult,
   extractCharterSlackPeers,
   extractCharterTelegramPeers,
+  hasActionableItems,
   hasHybridActionableItems,
   hasRevokedResiduals,
+  isHybridActionable,
   isKanbanHybridDryRun,
   isKanbanHybridEnabled,
   isKanbanWorkCronDisabled,
+  isPlainScheduledTemplate,
+  isScheduledCardTracked,
+  isScheduledViaKanbanEnabled,
   markAgentForFreshMemorySync,
   maybeInjectKanbanCheck,
   maybeUpgradeClaudeCode,
+  reconcileScheduledRuns,
+  routeScheduledTaskViaKanban,
   shouldSkipRevokedCleanup,
   stampClaudeCodeUpgradeMarker,
   startManager,