@slock-ai/daemon 0.43.0 → 0.44.2

package/dist/chat-bridge.js

@@ -1323,7 +1323,7 @@ Thread messages and system messages (e.g. task-claim / task-status announcements
             const msgShort = r.messageId ? r.messageId.slice(0, 8) : "";
             return `${label} (msg:${msgShort}): claimed`;
           }
-          return `${label}: FAILED \u2014 ${r.reason || "already claimed"}`;
+          return `${label}: FAILED \u2014 ${r.reason || "already claimed"}. Do not reply.`;
         });
         const succeeded = data.results.filter((r) => r.success).length;
         const failed = data.results.length - succeeded;

package/dist/{chunk-37O7EHYE.js → chunk-NM2MFLQ7.js}

@@ -1328,8 +1328,25 @@ function probeClaude(deps = {}) {
 }
 var ClaudeDriver = class {
   id = "claude";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "gated",
+    inFlightWake: "queue"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
+  usesSlockCliForCommunication = true;
   // Claude Code supports same-turn steering, but raw stdin injection at an
   // arbitrary busy instant can collide with active signed thinking blocks. The
   // daemon therefore gates busy delivery on Claude stream-json boundaries.
@@ -1631,8 +1648,25 @@ function joinReasoningText(item) {
 }
 var CodexDriver = class {
   id = "codex";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp_chat_";
+  usesSlockCliForCommunication = true;
   busyDeliveryMode = "direct";
   supportsNativeStandingPrompt = true;
   probe() {
@@ -2027,7 +2061,7 @@ function detectCodexModels(home = os.homedir()) {
       if (entry?.visibility && entry.visibility !== "public") continue;
       if (entry?.supported_in_api === false) continue;
       const label = typeof entry?.display_name === "string" && entry.display_name.length > 0 ? entry.display_name : slug;
-      models.push({ id: slug, label });
+      models.push({ id: slug, label, verified: "launchable" });
     }
   } catch {
     return null;
@@ -2049,6 +2083,23 @@ import path5 from "path";
 import { writeFileSync as writeFileSync3 } from "fs";
 var CopilotDriver = class {
   id = "copilot";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "";
   busyDeliveryMode = "none";
@@ -2182,11 +2233,28 @@ var CopilotDriver = class {
 };
 
 // src/drivers/cursor.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn4, spawnSync } from "child_process";
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import path6 from "path";
 var CursorDriver = class {
   id = "cursor";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "mcp__chat__";
   busyDeliveryMode = "none";
@@ -2299,7 +2367,48 @@ var CursorDriver = class {
       messageNotificationStyle: "poll"
     });
   }
+  async detectModels() {
+    return detectCursorModels();
+  }
 };
+function parseCursorModelsOutput(output) {
+  const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+  const models = [];
+  let defaultModel;
+  for (const rawLine of stripAnsi(output).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || /^available models$/i.test(line) || /^tip:/i.test(line)) continue;
+    if (/^no models available/i.test(line) || /^failed to load models:/i.test(line)) continue;
+    let modelLine = line;
+    const markerMatch = modelLine.match(/\s+\(([^)]+)\)$/);
+    const markers = markerMatch?.[1]?.split(",").map((part) => part.trim().toLowerCase()) ?? [];
+    if (markers.length > 0 && markers.every((part) => part === "current" || part === "default")) {
+      const markerStart = markerMatch?.index ?? modelLine.length;
+      modelLine = modelLine.slice(0, markerStart).trim();
+    }
+    const match = modelLine.match(/^(\S+)(?:\s+-\s+(.+))?$/);
+    if (!match) continue;
+    const id = match[1]?.trim();
+    if (!id || id.startsWith("-")) continue;
+    const label = match[2]?.trim() || id;
+    models.push({ id, label, verified: "launchable" });
+    if (markers.includes("default")) defaultModel = id;
+  }
+  if (models.length === 0) return null;
+  return { models, default: defaultModel };
+}
+function detectCursorModels(runCommand = runCursorModelsCommand) {
+  const result = runCommand();
+  if (result.error || result.status !== 0) return null;
+  return parseCursorModelsOutput(String(result.stdout || ""));
+}
+function runCursorModelsCommand() {
+  return spawnSync("cursor-agent", ["models"], {
+    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    encoding: "utf8",
+    timeout: 5e3
+  });
+}
 
 // src/drivers/gemini.ts
 import { spawn as spawn5 } from "child_process";
@@ -2318,6 +2427,23 @@ function buildGeminiSpawnEnv(ctx) {
 }
 var GeminiDriver = class {
   id = "gemini";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "";
   busyDeliveryMode = "none";
@@ -2447,6 +2573,22 @@ function parseToolArguments(raw) {
 }
 var KimiDriver = class {
   id = "kimi";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
   busyDeliveryMode = "direct";
@@ -2647,7 +2789,7 @@ function detectKimiModels(home = os2.homedir()) {
     let key = match[1].trim();
     if (key.startsWith('"') && key.endsWith('"')) key = key.slice(1, -1);
     if (!key) continue;
-    models.push({ id: key, label: key });
+    models.push({ id: key, label: key, verified: "launchable" });
   }
   void sectionRe;
   if (models.length === 0) return null;
@@ -2802,7 +2944,10 @@ function buildOpenCodeLaunchOptions(ctx, home = os3.homedir()) {
   return { args, env, config };
 }
 function detectOpenCodeModels(home = os3.homedir()) {
-  const models = [...RUNTIME_MODELS.opencode || []];
+  const models = (RUNTIME_MODELS.opencode || []).map((model) => ({
+    ...model,
+    verified: "suggestion_only"
+  }));
   const providers = recordField(readLocalOpenCodeConfig(home).provider);
   for (const [providerId, providerConfig] of Object.entries(providers)) {
     const providerModels = recordField(recordField(providerConfig).models);
@@ -2811,7 +2956,7 @@ function detectOpenCodeModels(home = os3.homedir()) {
       if (models.some((model2) => model2.id === fullId)) continue;
       const model = recordField(modelConfig);
       const name = typeof model.name === "string" && model.name.length > 0 ? model.name : fullId;
-      models.push({ id: fullId, label: name });
+      models.push({ id: fullId, label: name, verified: "launchable" });
     }
   }
   return models.length > 0 ? { models } : null;
@@ -2834,6 +2979,38 @@ function buildOpenCodeSystemPrompt(config) {
 }
 var OpenCodeDriver = class {
   id = "opencode";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildOpenCodeLaunchOptions(launchCtx, opts?.home);
+      return {
+        args: launch.args,
+        env: launch.env,
+        config: launch.config
+      };
+    }
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = CHAT_MCP_TOOL_PREFIX;
   busyDeliveryMode = "none";
@@ -3060,6 +3237,22 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 
 // src/agentProcessManager.ts
 var DATA_DIR = path11.join(os4.homedir(), ".slock", "agents");
+var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 1;
+var DEFAULT_AGENT_START_INTERVAL_MS = 500;
+function readPositiveIntegerEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.floor(parsed);
+}
+function readNonNegativeIntegerEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return fallback;
+  return Math.floor(parsed);
+}
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -3783,6 +3976,15 @@ var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
   // Prevent concurrent starts of same agent
+  queuedAgentStarts = /* @__PURE__ */ new Map();
+  agentStartQueue = [];
+  activeAgentStartPermits = /* @__PURE__ */ new Set();
+  activeAgentStartCount = 0;
+  agentStartPumpTimer = null;
+  lastAgentStartAt = 0;
+  lastAgentStartAgentId = null;
+  maxConcurrentAgentStarts;
+  agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
@@ -3807,8 +4009,137 @@ var AgentProcessManager = class _AgentProcessManager {
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
+    this.maxConcurrentAgentStarts = Math.max(
+      1,
+      Math.floor(
+        opts.runtimeStartScheduler?.maxConcurrentStarts ?? readPositiveIntegerEnv("SLOCK_DAEMON_MAX_CONCURRENT_AGENT_STARTS", DEFAULT_MAX_CONCURRENT_AGENT_STARTS)
+      )
+    );
+    this.agentStartIntervalMs = Math.max(
+      0,
+      Math.floor(
+        opts.runtimeStartScheduler?.minStartIntervalMs ?? readNonNegativeIntegerEnv("SLOCK_DAEMON_AGENT_START_INTERVAL_MS", DEFAULT_AGENT_START_INTERVAL_MS)
+      )
+    );
   }
   async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+    if (this.agents.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      return;
+    }
+    if (this.agentsStarting.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      return;
+    }
+    if (this.queuedAgentStarts.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (startup already queued)`);
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const item = {
+        agentId,
+        config,
+        wakeMessage,
+        unreadSummary,
+        resumePrompt,
+        launchId,
+        resolve,
+        reject
+      };
+      this.agentStartQueue.push(item);
+      this.queuedAgentStarts.set(agentId, item);
+      logger.info(
+        `[Agent ${agentId}] Start queued (queue=${this.agentStartQueue.length}, active=${this.activeAgentStartCount}, max=${this.maxConcurrentAgentStarts}, interval=${this.agentStartIntervalMs}ms)`
+      );
+      this.pumpAgentStartQueue();
+    });
+  }
+  pumpAgentStartQueue() {
+    if (this.agentStartPumpTimer) return;
+    if (this.agentStartQueue.length === 0) return;
+    if (this.activeAgentStartCount >= this.maxConcurrentAgentStarts) return;
+    const next = this.agentStartQueue[0];
+    const shouldRateLimit = next ? next.agentId !== this.lastAgentStartAgentId : true;
+    const elapsed = Date.now() - this.lastAgentStartAt;
+    const waitMs = shouldRateLimit ? Math.max(0, this.agentStartIntervalMs - elapsed) : 0;
+    if (waitMs > 0) {
+      this.agentStartPumpTimer = setTimeout(() => {
+        this.agentStartPumpTimer = null;
+        this.pumpAgentStartQueue();
+      }, waitMs);
+      return;
+    }
+    const item = this.agentStartQueue.shift();
+    if (!item) return;
+    if (this.queuedAgentStarts.get(item.agentId) !== item) {
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.queuedAgentStarts.delete(item.agentId);
+    if (this.agents.has(item.agentId) || this.agentsStarting.has(item.agentId)) {
+      logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
+      item.resolve();
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.activeAgentStartCount++;
+    this.activeAgentStartPermits.add(item.agentId);
+    this.lastAgentStartAt = Date.now();
+    this.lastAgentStartAgentId = item.agentId;
+    logger.info(
+      `[Agent ${item.agentId}] Dequeued start (remaining=${this.agentStartQueue.length}, active=${this.activeAgentStartCount})`
+    );
+    this.startAgentNow(
+      item.agentId,
+      item.config,
+      item.wakeMessage,
+      item.unreadSummary,
+      item.resumePrompt,
+      item.launchId
+    ).then(item.resolve, (err) => {
+      this.releaseAgentStartPermit(item.agentId, "start failed");
+      item.reject(err);
+    });
+  }
+  releaseAgentStartPermit(agentId, reason) {
+    if (!this.activeAgentStartPermits.delete(agentId)) return false;
+    this.activeAgentStartCount = Math.max(0, this.activeAgentStartCount - 1);
+    logger.info(
+      `[Agent ${agentId}] Start permit released (${reason}) (active=${this.activeAgentStartCount}, queue=${this.agentStartQueue.length})`
+    );
+    this.pumpAgentStartQueue();
+    return true;
+  }
+  cancelQueuedAgentStart(agentId, reason) {
+    const item = this.queuedAgentStarts.get(agentId);
+    if (!item) return false;
+    this.queuedAgentStarts.delete(agentId);
+    this.agentStartQueue = this.agentStartQueue.filter((candidate) => candidate !== item);
+    this.startingInboxes.delete(agentId);
+    if (this.agentStartQueue.length === 0 && this.agentStartPumpTimer) {
+      clearTimeout(this.agentStartPumpTimer);
+      this.agentStartPumpTimer = null;
+    }
+    logger.info(`[Agent ${agentId}] Queued start cancelled (${reason})`);
+    item.resolve();
+    return true;
+  }
+  cancelAllQueuedAgentStarts(reason) {
+    for (const item of this.agentStartQueue) {
+      if (this.queuedAgentStarts.get(item.agentId) === item) {
+        logger.info(`[Agent ${item.agentId}] Queued start cancelled (${reason})`);
+        item.resolve();
+      }
+    }
+    this.agentStartQueue = [];
+    this.queuedAgentStarts.clear();
+    this.startingInboxes.clear();
+    if (this.agentStartPumpTimer) {
+      clearTimeout(this.agentStartPumpTimer);
+      this.agentStartPumpTimer = null;
+    }
+  }
+  async startAgentNow(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
     if (this.agents.has(agentId)) {
       logger.info(`[Agent ${agentId}] Start ignored (already running)`);
       return;
@@ -3910,6 +4241,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.sendAgentStatus(agentId, "active", launchId || null);
         this.broadcastActivity(agentId, "online", "Process idle");
         logger.info(`[Agent ${agentId}] Deferred ${driver.id} spawn until first concrete message`);
+        this.releaseAgentStartPermit(agentId, "spawn deferred");
         for (const message of pendingMessages) {
           this.deliverMessage(agentId, message);
         }
@@ -3947,6 +4279,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtimeTraceSpan: null,
         lastActivity: "",
         lastActivityDetail: "",
+        activityClientSeq: 0,
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
@@ -4012,6 +4345,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (this.agents.has(agentId)) {
           const ap = this.agents.get(agentId);
           if (ap.process !== proc) return;
+          this.releaseAgentStartPermit(agentId, "process closed");
           if (ap.notificationTimer) {
             clearTimeout(ap.notificationTimer);
           }
@@ -4176,6 +4510,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return leftKeys.every((key) => left?.[key] === right?.[key]);
   }
   async stopAgent(agentId, { wait = false, silent = false } = {}) {
+    this.cancelQueuedAgentStart(agentId, "stop requested");
     this.idleAgentConfigs.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) {
@@ -4184,6 +4519,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
       return;
     }
+    this.releaseAgentStartPermit(agentId, "stop requested");
     if (ap.notificationTimer) {
       clearTimeout(ap.notificationTimer);
     }
@@ -4225,7 +4561,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   deliverMessage(agentId, message) {
     const ap = this.agents.get(agentId);
     if (!ap) {
-      if (this.agentsStarting.has(agentId)) {
+      if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
         const pending = this.startingInboxes.get(agentId) || [];
         pending.push(message);
         this.startingInboxes.set(agentId, pending);
@@ -4285,6 +4621,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   async stopAll() {
+    this.cancelAllQueuedAgentStarts("daemon shutdown");
     this.idleAgentConfigs.clear();
     const ids = [...this.agents.keys()];
     await Promise.all(ids.map((id) => this.stopAgent(id, { wait: true, silent: true })));
@@ -4619,13 +4956,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (!hasToolStart) {
       entries.push({ kind: "status", activity, detail });
     }
+    if (ap) ap.activityClientSeq += 1;
     this.sendToServer({
       type: "agent:activity",
       agentId,
       activity,
       detail,
       entries,
-      launchId: launchIdOverride || ap?.launchId || void 0
+      launchId: launchIdOverride || ap?.launchId || void 0,
+      clientSeq: ap?.activityClientSeq
     });
     if (ap) {
       ap.lastActivity = activity;
@@ -4637,12 +4976,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             this.recordRuntimeTraceEvent(agentId, ap, "activity.heartbeat.sent", {
               activity: ap.lastActivity
             });
+            ap.activityClientSeq += 1;
             this.sendToServer({
               type: "agent:activity",
               agentId,
               activity: ap.lastActivity,
               detail: ap.lastActivityDetail,
-              launchId: launchIdOverride || ap.launchId || void 0
+              launchId: launchIdOverride || ap.launchId || void 0,
+              clientSeq: ap.activityClientSeq
             });
           }, ACTIVITY_HEARTBEAT_MS);
         }
@@ -4654,6 +4995,42 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
     }
   }
+  /**
+   * Respond to a server-issued `agent:activity_probe`. Echoes the
+   * agent's current `lastActivity` back through the existing
+   * `agent:activity` upstream channel with the matching `probeId`.
+   *
+   * Why this exists: the server's stale-activity sweep used to
+   * synthesize `online` whenever a transient state went 90s without
+   * an update. That invented state without consulting ground truth
+   * and produced "agent shows green/idle but is actually working" UI
+   * staleness (#engineering:72283cf7 task #340 RCA).
+   *
+   * The new flow: server sends `agent:activity_probe` for stale
+   * agents, daemon replies here with the *real* current activity, and
+   * the server only falls back to synth-online if the probe times out
+   * (5s). The body is intentionally minimal — no entries, no
+   * heartbeat side-effects, no state mutation. We just echo what we
+   * already know.
+   *
+   * If the agent is no longer running locally (`ap` undefined), we
+   * report `offline` so the server stops believing the agent is busy.
+   */
+  respondToActivityProbe(agentId, probeId) {
+    const ap = this.agents.get(agentId);
+    const activity = ap?.lastActivity || "offline";
+    const detail = ap?.lastActivityDetail || (ap ? "" : "Agent not running");
+    if (ap) ap.activityClientSeq += 1;
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity,
+      detail,
+      launchId: ap?.launchId || void 0,
+      probeId,
+      clientSeq: ap?.activityClientSeq
+    });
+  }
   flushPendingTrajectory(agentId) {
     const ap = this.agents.get(agentId);
     const pending = ap?.pendingTrajectory;
@@ -4945,6 +5322,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from turn end)");
         this.flushPendingTrajectory(agentId);
         if (ap) {
+          this.releaseAgentStartPermit(agentId, "initial turn ended");
           this.clearGatedInFlightBatch(agentId, ap, "turn_end");
           if (event.sessionId) ap.sessionId = event.sessionId;
           ap.gatedSteering.outstandingToolUses = 0;
@@ -5534,6 +5912,8 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, path=${msg.path})`;
     case "agent:skills:list":
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
+    case "agent:activity_probe":
+      return `(agent=${msg.agentId}, probe=${msg.probeId.slice(0, 8)}, purpose=${msg.purpose})`;
     case "machine:workspace:delete":
       return `(directory=${msg.directoryName})`;
     case "machine:runtime_models:detect":
@@ -5721,6 +6101,9 @@ var DaemonCore = class {
           this.connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
         });
         break;
+      case "agent:activity_probe":
+        this.agentManager.respondToActivityProbe(msg.agentId, msg.probeId);
+        break;
       case "machine:workspace:scan":
         logger.info("[Daemon] Scanning all workspace directories");
         this.agentManager.scanAllWorkspaces().then((directories) => {
@@ -5738,7 +6121,12 @@ var DaemonCore = class {
         const detect = typeof driver?.detectModels === "function" ? driver.detectModels() : Promise.resolve(null);
         Promise.resolve(detect).then((result) => {
           if (result) {
-            this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, models: result.models, default: result.default });
+            const verified = driver.model.detectedModelsVerifiedAs;
+            const models = result.models.map((model) => ({
+              ...model,
+              verified: model.verified ?? verified
+            }));
+            this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, models, default: result.default });
           } else {
             this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: "unsupported" });
           }

package/dist/cli/index.js

@@ -1049,7 +1049,7 @@ function formatClaimResults(channel, data) {
       const msgShort = r.messageId ? r.messageId.slice(0, 8) : "";
       return `${label} (msg:${msgShort}): claimed`;
     }
-    return `${label}: FAILED \u2014 ${r.reason || "already claimed"}`;
+    return `${label}: FAILED \u2014 ${r.reason || "already claimed"}. Do not reply.`;
   });
   const succeeded = data.results.filter((r) => r.success).length;
   const failed = data.results.length - succeeded;
@@ -1681,20 +1681,18 @@ function registerProfileUpdateCommand(parent) {
 }
 
 // src/commands/reminder/_format.ts
-function toLocalTime2(iso) {
-  const d = new Date(iso);
-  if (isNaN(d.getTime())) return iso;
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
+var MODIFY_HINT = "(to modify: snooze/update/cancel; slock reminder --help)";
 function formatReminder(r) {
-  const fireLocal = toLocalTime2(r.fireAt);
   const ref = r.msgRef ? ` ref=${r.msgRef}` : "";
-  const repeat = r.recurrence ? ` repeat=${r.recurrence.description}` : "";
-  return `#${r.reminderId.slice(0, 8)} [${r.status}] fires=${fireLocal} "${r.title}"${ref}${repeat}`;
+  const timeField = r.status === "fired" ? `fired_at=${r.firedAt ?? r.fireAt}` : `next=${r.fireAt}`;
+  return `#${r.reminderId.slice(0, 8)} [${r.status}] ${formatReminderType(r)} ${timeField} "${r.title}"${ref}`;
 }
 function formatReminderScheduled(r, warning) {
-  const lines = [`Reminder scheduled: ${formatReminder(r)}`];
+  const lines = [
+    `Reminder scheduled: #${r.reminderId.slice(0, 8)} ${formatReminderType(r)} "${r.title}"`,
+    `Next: ${r.fireAt}`,
+    MODIFY_HINT
+  ];
   if (warning) lines.push(`Warning: ${warning}`);
   return lines.join("\n");
 }
@@ -1703,7 +1701,34 @@ function formatReminderList(reminders) {
   return reminders.map(formatReminder).join("\n");
 }
 function formatReminderCanceled(r) {
-  return `Reminder canceled: ${formatReminder(r)}`;
+  return `Reminder canceled: #${r.reminderId.slice(0, 8)} [${r.status}] "${r.title}"`;
+}
+function formatReminderSnoozed(r) {
+  return [
+    `Reminder snoozed: #${r.reminderId.slice(0, 8)} ${formatReminderType(r)} "${r.title}"`,
+    `Next: ${r.fireAt}`,
+    MODIFY_HINT
+  ].join("\n");
+}
+function formatReminderUpdated(r, warning) {
+  const lines = [
+    `Reminder updated: #${r.reminderId.slice(0, 8)} ${formatReminderType(r)} "${r.title}"`,
+    `Next: ${r.fireAt}`,
+    MODIFY_HINT
+  ];
+  if (warning) lines.push(`Warning: ${warning}`);
+  return lines.join("\n");
+}
+function formatReminderLog(events) {
+  if (events.length === 0) return "No reminder events.";
+  return events.map((event) => {
+    const next = event.nextFireAt ? ` next=${event.nextFireAt}` : " next=none";
+    return `${event.occurredAt} ${event.eventType.toUpperCase()} by ${event.actorType}${event.actorId ? `:${event.actorId}` : ""}${next}`;
+  }).join("\n");
+}
+function formatReminderType(r) {
+  if (!r.recurrence) return "(one-time)";
+  return `(recurring \xB7 ${r.recurrence.description})`;
 }
 
 // src/commands/reminder/schedule.ts
@@ -1799,9 +1824,9 @@ function registerReminderScheduleCommand(parent) {
 // src/commands/reminder/list.ts
 var VALID_STATUSES2 = /* @__PURE__ */ new Set(["scheduled", "fired", "canceled"]);
 function registerReminderListCommand(parent) {
-  parent.command("list").description("List your own reminders (defaults to scheduled)").option(
+  parent.command("list").description("List your own reminders (defaults to scheduled and fired)").option("--all", "Include canceled reminders").option(
     "--status <s>",
-    "Comma-separated statuses (scheduled,fired,canceled). Default: scheduled"
+    "Comma-separated statuses (scheduled,fired,canceled). Default: scheduled,fired"
   ).action(async (opts) => {
     let ctx;
     try {
@@ -1810,14 +1835,18 @@ function registerReminderListCommand(parent) {
       if (err instanceof AgentBootstrapError) fail(err.code, err.message);
       throw err;
     }
-    const statusRaw = opts.status && opts.status.trim().length > 0 ? opts.status.trim() : "scheduled";
+    const statusRaw = opts.status && opts.status.trim().length > 0 ? opts.status.trim() : "scheduled,fired";
     for (const s of statusRaw.split(",").map((x) => x.trim()).filter(Boolean)) {
       if (!VALID_STATUSES2.has(s)) {
         fail("INVALID_ARG", `--status entries must be one of ${Array.from(VALID_STATUSES2).join("|")}; got ${s}`);
       }
     }
     const params = new URLSearchParams();
-    params.set("status", statusRaw);
+    if (opts.all && !opts.status) {
+      params.set("all", "true");
+    } else {
+      params.set("status", statusRaw);
+    }
     const client = new ApiClient(ctx);
     const res = await client.request(
       "GET",
@@ -1831,6 +1860,37 @@ function registerReminderListCommand(parent) {
   });
 }
 
+// src/commands/reminder/_resolve.ts
+async function resolveReminderId(client, agentId, id, opts) {
+  const trimmed = id.trim();
+  if (!trimmed) fail("INVALID_ARG", "--id is required");
+  if (trimmed.length >= 32) return trimmed;
+  const params = new URLSearchParams();
+  if (opts.all) {
+    params.set("all", "true");
+  } else if (opts.statuses && opts.statuses.length > 0) {
+    params.set("status", opts.statuses.join(","));
+  }
+  const query = params.toString();
+  const res = await client.request(
+    "GET",
+    `/internal/agent/${encodeURIComponent(agentId)}/reminders${query ? `?${query}` : ""}`
+  );
+  if (!res.ok) {
+    const code = res.status >= 500 ? "SERVER_5XX" : opts.failureCode;
+    fail(code, res.error ?? `HTTP ${res.status}`);
+  }
+  const matches = (res.data?.reminders ?? []).filter((r) => r.reminderId.startsWith(trimmed));
+  if (matches.length === 0) {
+    const scope = opts.all ? "reminder" : `${opts.statuses?.join("/") ?? "active"} reminder`;
+    fail("NOT_FOUND", `No ${scope} matches id prefix '${trimmed}'.`);
+  }
+  if (matches.length > 1) {
+    fail("AMBIGUOUS", `Ambiguous id prefix '${trimmed}' matches ${matches.length} reminders; pass a longer id.`);
+  }
+  return matches[0].reminderId;
+}
+
 // src/commands/reminder/cancel.ts
 function registerReminderCancelCommand(parent) {
   parent.command("cancel").description("Cancel a scheduled reminder by id (full uuid or 8-char prefix)").requiredOption("--id <id>", "Reminder id (full uuid or short prefix)").action(async (opts) => {
@@ -1845,25 +1905,10 @@ function registerReminderCancelCommand(parent) {
       fail("INVALID_ARG", "--id is required");
     }
     const client = new ApiClient(ctx);
-    let fullId = opts.id;
-    if (opts.id.length < 32) {
-      const listRes = await client.request(
-        "GET",
-        `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders?status=scheduled`
-      );
-      if (!listRes.ok) {
-        const code = listRes.status >= 500 ? "SERVER_5XX" : "CANCEL_FAILED";
-        fail(code, listRes.error ?? `HTTP ${listRes.status}`);
-      }
-      const matches = (listRes.data?.reminders ?? []).filter((r) => r.reminderId.startsWith(opts.id));
-      if (matches.length === 0) {
-        fail("NOT_FOUND", `No scheduled reminder matches id prefix '${opts.id}'.`);
-      }
-      if (matches.length > 1) {
-        fail("AMBIGUOUS", `Ambiguous id prefix '${opts.id}' matches ${matches.length} reminders; pass a longer id.`);
-      }
-      fullId = matches[0].reminderId;
-    }
+    const fullId = await resolveReminderId(client, ctx.agentId, opts.id, {
+      statuses: ["scheduled", "fired"],
+      failureCode: "CANCEL_FAILED"
+    });
     const res = await client.request(
       "DELETE",
       `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders/${encodeURIComponent(fullId)}`
@@ -1876,6 +1921,124 @@ function registerReminderCancelCommand(parent) {
   });
 }
 
+// src/commands/reminder/_duration.ts
+function parseDurationSeconds(input) {
+  const raw = input.trim();
+  const match = /^(\d+)(s|m|h|d)?$/.exec(raw);
+  if (!match) return null;
+  const value = Number(match[1]);
+  const unit = match[2] ?? "s";
+  const multiplier = unit === "s" ? 1 : unit === "m" ? 60 : unit === "h" ? 3600 : 86400;
+  const seconds = value * multiplier;
+  if (!Number.isSafeInteger(seconds) || seconds <= 0) return null;
+  return seconds;
+}
+
+// src/commands/reminder/snooze.ts
+function registerReminderSnoozeCommand(parent) {
+  parent.command("snooze").description("Snooze a scheduled or fired reminder").requiredOption("--id <id>", "Reminder id (full uuid or short prefix)").requiredOption("--by <duration>", "Snooze duration, e.g. 30m, 2h, 1d").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const delaySeconds = parseDurationSeconds(opts.by);
+    if (delaySeconds == null) {
+      fail("INVALID_ARG", "--by must be a positive duration like 30m, 2h, or 1d");
+    }
+    const client = new ApiClient(ctx);
+    const fullId = await resolveReminderId(client, ctx.agentId, opts.id, {
+      statuses: ["scheduled", "fired"],
+      failureCode: "SNOOZE_FAILED"
+    });
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders/${encodeURIComponent(fullId)}/snooze`,
+      { delaySeconds }
+    );
+    if (!res.ok || !res.data?.reminder) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "SNOOZE_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderSnoozed(res.data.reminder) + "\n");
+  });
+}
+
+// src/commands/reminder/update.ts
+function registerReminderUpdateCommand(parent) {
+  parent.command("update").description("Update one field on a scheduled reminder").requiredOption("--id <id>", "Reminder id (full uuid or short prefix)").option("--fire-at <iso>", "New absolute next fire time").option("--in <duration>", "New relative next fire time, e.g. 30m, 2h").option("--cadence <rule>", "New recurrence rule: every:15m | daily@09:00 | weekly:mon,fri@09:00").option("--title <text>", "New reminder title").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const mutationCount = [opts.fireAt, opts.in, opts.cadence, opts.title].filter((x) => x !== void 0 && x !== null).length;
+    if (mutationCount !== 1) {
+      fail("INVALID_ARG", "Pass exactly one of --fire-at, --in, --cadence, or --title");
+    }
+    const body = {};
+    if (opts.fireAt !== void 0) body.fireAt = opts.fireAt;
+    if (opts.in !== void 0) {
+      const delaySeconds = parseDurationSeconds(opts.in);
+      if (delaySeconds == null) {
+        fail("INVALID_ARG", "--in must be a positive duration like 30m, 2h, or 1d");
+      }
+      body.delaySeconds = delaySeconds;
+    }
+    if (opts.cadence !== void 0) {
+      body.repeat = opts.cadence;
+      body.tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    if (opts.title !== void 0) body.title = opts.title;
+    const client = new ApiClient(ctx);
+    const fullId = await resolveReminderId(client, ctx.agentId, opts.id, {
+      all: true,
+      failureCode: "UPDATE_FAILED"
+    });
+    const res = await client.request(
+      "PATCH",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders/${encodeURIComponent(fullId)}`,
+      body
+    );
+    if (!res.ok || !res.data?.reminder) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "UPDATE_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderUpdated(res.data.reminder, res.data.warning ?? null) + "\n");
+  });
+}
+
+// src/commands/reminder/log.ts
+function registerReminderLogCommand(parent) {
+  parent.command("log").description("Show lifecycle events for one reminder").requiredOption("--id <id>", "Reminder id (full uuid or short prefix)").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    const fullId = await resolveReminderId(client, ctx.agentId, opts.id, {
+      all: true,
+      failureCode: "LOG_FAILED"
+    });
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders/${encodeURIComponent(fullId)}/log`
+    );
+    if (!res.ok || !res.data?.events) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "LOG_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderLog(res.data.events) + "\n");
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("slock").description(
@@ -1911,6 +2074,9 @@ var reminderCmd = program.command("reminder").description("Reminder operations")
 registerReminderScheduleCommand(reminderCmd);
 registerReminderListCommand(reminderCmd);
 registerReminderCancelCommand(reminderCmd);
+registerReminderSnoozeCommand(reminderCmd);
+registerReminderUpdateCommand(reminderCmd);
+registerReminderLogCommand(reminderCmd);
 program.parseAsync().catch((err) => {
   if (err instanceof CliExit) {
     process.exitCode = err.exitCode;

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-37O7EHYE.js";
+} from "./chunk-NM2MFLQ7.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-JG7ONJZ6.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-37O7EHYE.js";
+} from "./chunk-NM2MFLQ7.js";
 import "./chunk-JG7ONJZ6.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.43.0",
+  "version": "0.44.2",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"