chatroom-cli 1.36.1 → 1.37.2

package/dist/index.js

@@ -13426,6 +13426,10 @@ function startSessionEventForwarder(client4, options) {
   const errorTarget = options.errorTarget ?? process.stderr;
   let cancelled = false;
   let doneResolve;
+  let sessionStarted = false;
+  const seenToolStates = new Map;
+  let lastStatus;
+  const agentEndCallbacks = [];
   const donePromise = new Promise((resolve) => {
     doneResolve = resolve;
   });
@@ -13445,31 +13449,76 @@ function startSessionEventForwarder(client4, options) {
         const eventSession = eventSessionId(event);
         if (eventSession && eventSession !== options.sessionId)
           continue;
-        if (eventSession === undefined && event.type !== "session.idle" && event.type !== "session.compacted" && event.type !== "session.error" && event.type !== "session.status" && event.type !== "file.edited")
+        if (eventSession === undefined && event.type !== "message.part.updated" && event.type !== "session.idle" && event.type !== "session.compacted" && event.type !== "session.error" && event.type !== "session.status" && event.type !== "file.edited")
           continue;
+        if (!sessionStarted) {
+          sessionStarted = true;
+          target.write(formatLogLine(options, "session] Started", `role: ${options.role}`) + `
+`);
+        }
         switch (event.type) {
           case "message.part.updated": {
             const props = event.properties;
             const part = props?.part;
-            if (part?.type === "text" && part.delta) {
-              target.write(formatLogLine(options, "text", part.delta) + `
+            if (part?.type === "text") {
+              const chunk = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
+              if (chunk) {
+                target.write(formatLogLine(options, "text", chunk) + `
 `);
+              }
+            } else if (part?.type === "reasoning") {
+              const chunk = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
+              if (chunk) {
+                target.write(formatLogLine(options, "thinking", chunk) + `
+`);
+              }
             } else if (part?.type === "tool" && part.tool) {
-              const state = props?.state ?? "started";
-              target.write(formatLogLine(options, "tool: " + part.tool, state) + `
+              let appendInput = function(base, input, tool) {
+                if (!input || typeof input === "object" && Object.keys(input).length === 0) {
+                  return base;
+                }
+                const inp = input;
+                if (tool === "bash" && typeof inp.command === "string") {
+                  return `${base}: ${inp.command}`;
+                }
+                const inputStr = typeof inp === "string" ? inp : JSON.stringify(inp);
+                return `${base}: ${inputStr}`;
+              };
+              const state = typeof props?.state === "string" ? props.state : typeof part.state?.status === "string" ? part.state.status : "started";
+              let payload = state;
+              if (part.state?.input) {
+                payload = appendInput(payload, part.state.input, part.tool);
+              }
+              if (state === "completed" && part.state?.time?.start !== undefined && part.state?.time?.end !== undefined) {
+                const duration = ((part.state.time.end - part.state.time.start) / 1000).toFixed(1);
+                payload = appendInput(`${state} (${duration}s)`, part.state.input, part.tool);
+              }
+              const callID = part.callID ?? "unknown";
+              const seenKey = `${callID}:${state}`;
+              if (!seenToolStates.has(seenKey)) {
+                seenToolStates.set(seenKey, payload);
+                target.write(formatLogLine(options, "tool: " + part.tool, payload) + `
 `);
+              }
+              if (state === "completed" || state === "error") {
+                seenToolStates.delete(seenKey);
+              }
             }
             break;
           }
           case "file.edited": {
             const props = event.properties;
-            target.write(formatLogLine(options, "file", props?.file) + `
+            const kind = props?.action ?? props?.kind;
+            const filePayload = kind ? `${props?.file} (${kind})` : props?.file;
+            target.write(formatLogLine(options, "file", filePayload) + `
 `);
             break;
           }
           case "session.idle": {
             target.write(formatLogLine(options, "agent_end") + `
 `);
+            for (const cb of agentEndCallbacks)
+              cb();
             break;
           }
           case "session.compacted": {
@@ -13479,15 +13528,25 @@ function startSessionEventForwarder(client4, options) {
           }
           case "session.status": {
             const props = event.properties;
-            target.write(formatLogLine(options, "status", props?.status?.type) + `
+            const currentStatus = props?.status?.type;
+            if (currentStatus !== lastStatus) {
+              lastStatus = currentStatus;
+              target.write(formatLogLine(options, "status", currentStatus) + `
 `);
+            }
             break;
           }
           case "session.error": {
             const props = event.properties;
             const err = props?.error;
             const errMsg = err?.name ? `${err.name}${err?.data?.message ? ": " + err.data.message : ""}` : String(err ?? "unknown");
-            errorTarget.write(formatLogLine(options, "error", errMsg) + `
+            let payload = errMsg;
+            if (props?.tool) {
+              payload += ` [tool: ${props.tool}]`;
+            } else if (props?.command) {
+              payload += ` [command: ${props.command}]`;
+            }
+            errorTarget.write(formatLogLine(options, "error", payload) + `
 `);
             break;
           }
@@ -13508,7 +13567,10 @@ function startSessionEventForwarder(client4, options) {
     stop: () => {
       cancelled = true;
     },
-    done: donePromise
+    done: donePromise,
+    onAgentEnd: (cb) => {
+      agentEndCallbacks.push(cb);
+    }
   };
 }
 
@@ -13629,7 +13691,12 @@ var init_opencode_sdk_agent_service = __esm(() => {
             agent: selected.name,
             ...composedSystem ? { system: composedSystem } : {},
             parts: [{ type: "text", text: prompt }],
-            ...modelParts ? { model: modelParts } : {}
+            ...modelParts ? { model: modelParts } : {},
+            tools: {
+              task: false,
+              question: false,
+              external_directory: false
+            }
           }
         }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
       } catch (err) {
@@ -13688,6 +13755,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
         },
         onOutput: (cb) => {
           outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          forwarder?.onAgentEnd(cb);
         }
       };
     }
@@ -58879,6 +58949,13 @@ function handlePing() {
 // src/commands/machine/daemon-start/handlers/command-runner.ts
 import { spawn as spawn3 } from "node:child_process";
 import { access as access3 } from "node:fs/promises";
+function evictStalePendingStops() {
+  const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
+  for (const [runId, ts] of pendingStops) {
+    if (ts < evictBefore)
+      pendingStops.delete(runId);
+  }
+}
 async function reportRunFailed(ctx, runId, reason) {
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -58923,6 +59000,21 @@ async function onCommandRun(ctx, event) {
     console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
     return;
   }
+  if (pendingStops.has(runIdStr)) {
+    pendingStops.delete(runIdStr);
+    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId,
+        status: "stopped"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
+    }
+    return;
+  }
   console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
   if (!workingDir.startsWith("/")) {
     console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
@@ -58942,6 +59034,34 @@ async function onCommandRun(ctx, event) {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true
   });
+  const timeoutTimer = setTimeout(() => {
+    console.log(`[${formatTimestamp()}] ⏰ Command timed out after ${DEFAULT_COMMAND_TIMEOUT_MS / 60000} minutes: ${commandName} (runId: ${runIdStr})`);
+    const pid = child.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+    } else {
+      child.kill("SIGTERM");
+    }
+    setTimeout(() => {
+      if (!runningProcesses.has(runIdStr))
+        return;
+      console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
+      if (pid) {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      } else {
+        child.kill("SIGKILL");
+      }
+    }, SIGTERM_GRACE_PERIOD_MS);
+  }, DEFAULT_COMMAND_TIMEOUT_MS);
+  timeoutTimer.unref?.();
   const tracked = {
     process: child,
     runId: runIdStr,
@@ -58949,7 +59069,8 @@ async function onCommandRun(ctx, event) {
     chunkIndex: 0,
     flushTimer: setInterval(() => {
       flushOutput(ctx, tracked).catch(() => {});
-    }, OUTPUT_FLUSH_INTERVAL_MS)
+    }, OUTPUT_FLUSH_INTERVAL_MS),
+    timeoutTimer
   };
   tracked.flushTimer.unref?.();
   runningProcesses.set(runIdStr, tracked);
@@ -58974,6 +59095,8 @@ async function onCommandRun(ctx, event) {
     console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     await flushOutput(ctx, tracked).catch(() => {});
     clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
     runningProcesses.delete(runIdStr);
     const status = code2 === 0 ? "completed" : signal ? "stopped" : "failed";
     try {
@@ -58991,6 +59114,8 @@ async function onCommandRun(ctx, event) {
   child.on("error", async (err) => {
     console.error(`[${formatTimestamp()}] ❌ Command spawn failed: ${commandName}: ${err.message}`);
     clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
     runningProcesses.delete(runIdStr);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -59004,11 +59129,42 @@ async function onCommandRun(ctx, event) {
     }
   });
 }
+function killProcess(child, signal) {
+  const pid = child.pid;
+  if (pid) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {}
+  }
+  try {
+    child.kill(signal);
+  } catch {}
+}
+function waitForExit(runIdStr, ms) {
+  return new Promise((resolve5) => {
+    const interval = 100;
+    let elapsed = 0;
+    const timer = setInterval(() => {
+      if (!runningProcesses.has(runIdStr)) {
+        clearInterval(timer);
+        resolve5(true);
+        return;
+      }
+      elapsed += interval;
+      if (elapsed >= ms) {
+        clearInterval(timer);
+        resolve5(false);
+      }
+    }, interval);
+  });
+}
 async function onCommandStop(ctx, event) {
   const runIdStr = event.runId.toString();
   const tracked = runningProcesses.get(runIdStr);
   if (!tracked) {
-    console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr}`);
+    console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr} — marking as stopped`);
+    pendingStops.set(runIdStr, Date.now());
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -59016,44 +59172,85 @@ async function onCommandStop(ctx, event) {
         runId: event.runId,
         status: "stopped"
       });
-      console.log(`[${formatTimestamp()}] \uD83D\uDCDD Marked orphaned run as stopped: ${runIdStr}`);
     } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark orphaned run as stopped: ${getErrorMessage(err)}`);
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as stopped (will retry): ${getErrorMessage(err)}`);
+      throw err;
     }
     return;
   }
   console.log(`[${formatTimestamp()}] \uD83D\uDED1 Stopping command run: ${runIdStr}`);
-  const pid = tracked.process.pid;
-  if (pid) {
-    try {
-      process.kill(-pid, "SIGTERM");
-    } catch {
-      tracked.process.kill("SIGTERM");
-    }
-  } else {
-    tracked.process.kill("SIGTERM");
+  if (tracked.timeoutTimer) {
+    clearTimeout(tracked.timeoutTimer);
+    tracked.timeoutTimer = null;
   }
-  setTimeout(() => {
-    if (tracked.process.killed)
-      return;
+  killProcess(tracked.process, "SIGTERM");
+  const exitedAfterSigterm = await waitForExit(runIdStr, SIGTERM_GRACE_PERIOD_MS);
+  if (!exitedAfterSigterm) {
     console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${runIdStr}`);
+    killProcess(tracked.process, "SIGKILL");
+    const exitedAfterSigkill = await waitForExit(runIdStr, 1000);
+    if (!exitedAfterSigkill) {
+      console.error(`[${formatTimestamp()}] ❌ Failed to stop process for run: ${runIdStr} — process did not exit after SIGKILL`);
+    }
+  }
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId: event.runId,
+      status: "stopped"
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as stopped in backend: ${getErrorMessage(err)}`);
+  }
+}
+async function shutdownAllCommands(ctx) {
+  if (runningProcesses.size === 0)
+    return;
+  console.log(`[${formatTimestamp()}] Shutting down ${runningProcesses.size} running command(s)...`);
+  for (const [, tracked] of runningProcesses) {
+    clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
+    await flushOutput(ctx, tracked).catch(() => {});
+    const pid = tracked.process.pid;
     if (pid) {
       try {
-        process.kill(-pid, "SIGKILL");
+        process.kill(-pid, "SIGTERM");
       } catch {
-        tracked.process.kill("SIGKILL");
+        tracked.process.kill("SIGTERM");
       }
     } else {
-      tracked.process.kill("SIGKILL");
+      tracked.process.kill("SIGTERM");
+    }
+  }
+  await new Promise((resolve5) => {
+    const t = setTimeout(resolve5, 3000);
+    t.unref?.();
+  });
+  for (const [, tracked] of runningProcesses) {
+    const pid = tracked.process.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {}
+    } else {
+      try {
+        tracked.process.kill("SIGKILL");
+      } catch {}
     }
-  }, 5000);
+  }
+  runningProcesses.clear();
+  console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE;
+var runningProcesses, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, DEFAULT_COMMAND_TIMEOUT_MS, SIGTERM_GRACE_PERIOD_MS = 5000;
 var init_command_runner = __esm(() => {
   init_api3();
   init_convex_error();
   runningProcesses = new Map;
+  pendingStops = new Map;
   MAX_BUFFER_SIZE = 100 * 1024;
+  DEFAULT_COMMAND_TIMEOUT_MS = 30 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/handlers/state-recovery.ts
@@ -59097,6 +59294,14 @@ var init_state_recovery = __esm(() => {
   init_api3();
 });
 
+// src/commands/machine/daemon-start/capabilities-snapshot.ts
+function harnessCapabilitiesFingerprint(harnesses, versions) {
+  const h = [...harnesses].sort().join("\x01");
+  const keys = Object.keys(versions).sort();
+  const v3 = keys.map((k) => `${k}:${JSON.stringify(versions[k] ?? null)}`).join("\x02");
+  return `${h}::${v3}`;
+}
+
 // src/infrastructure/local-api/routes/identity.ts
 async function handleIdentity(_req, ctx) {
   const identity = {
@@ -60294,6 +60499,17 @@ async function recoverState(ctx) {
   } catch (e) {
     console.log(`   ⚠️  Failed to clear stale PIDs: ${getErrorMessage(e)}`);
   }
+  try {
+    const runResult = await ctx.deps.backend.mutation(api.commands.clearStaleCommandRuns, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    });
+    if (runResult.clearedCount > 0) {
+      console.log(`   \uD83E\uDDF9 Cleared ${runResult.clearedCount} stale command run(s) from backend`);
+    }
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear stale command runs: ${getErrorMessage(e)}`);
+  }
 }
 async function initDaemon() {
   if (!acquireLock()) {
@@ -60344,6 +60560,7 @@ async function initDaemon() {
         agentServices,
         lastPushedGitState: new Map,
         lastPushedModels: availableModels,
+        lastPushedHarnessFingerprint: harnessCapabilitiesFingerprint(config3.availableHarnesses, config3.harnessVersions),
         observedSyncEnabled: featureFlags.observedSyncEnabled ?? false
       };
       registerEventListeners(ctx);
@@ -60392,6 +60609,7 @@ var init_init2 = __esm(() => {
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 async function onDaemonShutdown(ctx) {
+  await shutdownAllCommands(ctx);
   const activeAgents = ctx.deps.agentProcessManager.listActive();
   if (activeAgents.length > 0) {
     console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s)...`);
@@ -60420,6 +60638,7 @@ async function onDaemonShutdown(ctx) {
 }
 var init_on_daemon_shutdown = __esm(() => {
   init_api3();
+  init_command_runner();
 });
 
 // src/infrastructure/git/git-writer.ts
@@ -60611,15 +60830,18 @@ function formatModelMap(map) {
   return Object.entries(map).map(([harness, models]) => `${harness}: ${models.join(", ")}`).join("; ");
 }
 async function refreshModels(ctx) {
-  if (!ctx.config)
-    return;
+  if (!ctx.config) {
+    return { kind: "noop" };
+  }
   const models = await discoverModels(ctx.agentServices);
   const freshConfig = ensureMachineRegistered();
   ctx.config.availableHarnesses = freshConfig.availableHarnesses;
   ctx.config.harnessVersions = freshConfig.harnessVersions;
-  const diff = diffModels(ctx.lastPushedModels, models);
-  if (!diff.hasChanges) {
-    return;
+  const modelDiff = diffModels(ctx.lastPushedModels, models);
+  const nextHarnessFingerprint = harnessCapabilitiesFingerprint(ctx.config.availableHarnesses, ctx.config.harnessVersions);
+  const harnessFingerprintChanged = ctx.lastPushedHarnessFingerprint !== null && nextHarnessFingerprint !== ctx.lastPushedHarnessFingerprint;
+  if (!modelDiff.hasChanges && !harnessFingerprintChanged) {
+    return { kind: "skipped_no_changes" };
   }
   const totalCount = Object.values(models).flat().length;
   try {
@@ -60631,15 +60853,19 @@ async function refreshModels(ctx) {
       availableModels: models
     });
     ctx.lastPushedModels = models;
-    if (Object.keys(diff.added).length > 0) {
-      console.log(`[${formatTimestamp()}] ➕ New models detected — ${formatModelMap(diff.added)}`);
+    ctx.lastPushedHarnessFingerprint = nextHarnessFingerprint;
+    if (Object.keys(modelDiff.added).length > 0) {
+      console.log(`[${formatTimestamp()}] ➕ New models detected — ${formatModelMap(modelDiff.added)}`);
     }
-    if (Object.keys(diff.removed).length > 0) {
-      console.log(`[${formatTimestamp()}] ➖ Models no longer available — ${formatModelMap(diff.removed)}`);
+    if (Object.keys(modelDiff.removed).length > 0) {
+      console.log(`[${formatTimestamp()}] ➖ Models no longer available — ${formatModelMap(modelDiff.removed)}`);
     }
     console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh pushed: ${totalCount > 0 ? `${totalCount} models` : "none discovered"}`);
+    return { kind: "pushed" };
   } catch (error) {
-    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${getErrorMessage(error)}`);
+    const message = getErrorMessage(error);
+    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${message}`);
+    return { kind: "failed", message };
   }
 }
 function evictStaleDedupEntries(tracker) {
@@ -60656,6 +60882,10 @@ function evictStaleDedupEntries(tracker) {
     if (ts2 < evictBefore)
       tracker.gitRefreshIds.delete(id);
   }
+  for (const [id, ts2] of tracker.capabilitiesRefreshIds) {
+    if (ts2 < evictBefore)
+      tracker.capabilitiesRefreshIds.delete(id);
+  }
   for (const [id, ts2] of tracker.localActionIds) {
     if (ts2 < evictBefore)
       tracker.localActionIds.delete(id);
@@ -60668,6 +60898,7 @@ function evictStaleDedupEntries(tracker) {
     if (ts2 < evictBefore)
       tracker.commandStopIds.delete(id);
   }
+  evictStalePendingStops();
 }
 async function dispatchCommandEvent(ctx, event, tracker) {
   const eventId = event._id.toString();
@@ -60675,40 +60906,40 @@ async function dispatchCommandEvent(ctx, event, tracker) {
   if (event.type === "agent.requestStart") {
     if (tracker.commandIds.has(eventId))
       return;
-    tracker.commandIds.set(eventId, Date.now());
     await onRequestStartAgent(ctx, event);
+    tracker.commandIds.set(eventId, Date.now());
   } else if (event.type === "agent.requestStop") {
     if (tracker.commandIds.has(eventId))
       return;
-    tracker.commandIds.set(eventId, Date.now());
     await onRequestStopAgent(ctx, event);
+    tracker.commandIds.set(eventId, Date.now());
   } else if (event.type === "daemon.ping") {
     if (tracker.pingIds.has(eventId))
       return;
-    tracker.pingIds.set(eventId, Date.now());
     handlePing();
     await ctx.deps.backend.mutation(api.machines.ackPing, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
       pingEventId: event._id
     });
+    tracker.pingIds.set(eventId, Date.now());
   } else if (event.type === "daemon.gitRefresh") {
     if (tracker.gitRefreshIds.has(eventId))
       return;
-    tracker.gitRefreshIds.set(eventId, Date.now());
     const stateKey = makeGitStateKey(ctx.machineId, event.workingDir);
     ctx.lastPushedGitState.delete(stateKey);
     console.log(`[${formatTimestamp()}] \uD83D\uDD04 Git refresh requested for ${event.workingDir}`);
     await pushGitState(ctx);
+    tracker.gitRefreshIds.set(eventId, Date.now());
   } else if (event.type === "daemon.localAction") {
     if (tracker.localActionIds.has(eventId))
       return;
-    tracker.localActionIds.set(eventId, Date.now());
     console.log(`[${formatTimestamp()}] \uD83D\uDDA5️  Local action: ${event.action} → ${event.workingDir}`);
     const result = await executeLocalAction(event.action, event.workingDir);
     if (!result.success) {
       console.warn(`[${formatTimestamp()}] ⚠️  Local action failed: ${result.error}`);
     }
+    tracker.localActionIds.set(eventId, Date.now());
   } else if (eventType === "command.run") {
     if (tracker.commandRunIds.has(eventId))
       return;
@@ -60717,8 +60948,42 @@ async function dispatchCommandEvent(ctx, event, tracker) {
   } else if (eventType === "command.stop") {
     if (tracker.commandStopIds.has(eventId))
       return;
-    tracker.commandStopIds.set(eventId, Date.now());
     await onCommandStop(ctx, event);
+    tracker.commandStopIds.set(eventId, Date.now());
+  } else if (event.type === "daemon.refreshCapabilities") {
+    if (tracker.capabilitiesRefreshIds.has(eventId))
+      return;
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Manual capabilities refresh requested`);
+    const outcome = await refreshModels(ctx);
+    tracker.capabilitiesRefreshIds.set(eventId, Date.now());
+    const batchId = "batchId" in event && event.batchId !== undefined ? event.batchId : undefined;
+    if (!batchId) {
+      return;
+    }
+    let status;
+    let errorMessage;
+    if (outcome.kind === "pushed") {
+      status = "completed";
+    } else if (outcome.kind === "skipped_no_changes") {
+      status = "skipped_no_changes";
+    } else if (outcome.kind === "failed") {
+      status = "failed";
+      errorMessage = outcome.message;
+    } else {
+      status = "failed";
+      errorMessage = "Daemon configuration unavailable";
+    }
+    try {
+      await ctx.deps.backend.mutation(api.machines.reportCapabilitiesRefreshResult, {
+        sessionId: ctx.sessionId,
+        batchId,
+        machineId: ctx.machineId,
+        status,
+        errorMessage
+      });
+    } catch (error) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Capabilities refresh report failed: ${getErrorMessage(error)}`);
+    }
   }
 }
 async function startCommandLoop(ctx) {
@@ -60790,6 +61055,7 @@ Listening for commands...`);
     commandIds: new Map,
     pingIds: new Map,
     gitRefreshIds: new Map,
+    capabilitiesRefreshIds: new Map,
     localActionIds: new Map,
     commandRunIds: new Map,
     commandStopIds: new Map
@@ -60810,15 +61076,8 @@ Listening for commands...`);
       }
     }
   });
-  const modelRefreshTimer = setInterval(() => {
-    refreshModels(ctx).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Model refresh error: ${getErrorMessage(err)}`);
-    });
-  }, MODEL_REFRESH_INTERVAL_MS);
-  modelRefreshTimer.unref();
   return await new Promise(() => {});
 }
-var MODEL_REFRESH_INTERVAL_MS;
 var init_command_loop = __esm(() => {
   init_on_request_start_agent();
   init_on_request_stop_agent();
@@ -60837,7 +61096,6 @@ var init_command_loop = __esm(() => {
   init_local_actions();
   init_machine();
   init_convex_error();
-  MODEL_REFRESH_INTERVAL_MS = 10 * 1000;
 });
 
 // src/commands/machine/daemon-start/index.ts
@@ -61934,5 +62192,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=C6BB51F249BBA12864756E2164756E21
+//# debugId=967EF2E82583BAE364756E2164756E21
 //# sourceMappingURL=index.js.map