@slock-ai/daemon 0.46.0 → 0.46.1-staging.20260509070837

package/dist/chat-bridge.js

@@ -34,7 +34,7 @@ var searchMessagesDeprecatedSchema = {
 };
 var listTasksDeprecatedSchema = {
   channel: z.string().describe("Deprecated channel argument."),
-  status: z.enum(["all", "todo", "in_progress", "in_review", "done"]).optional().describe("Deprecated status argument.")
+  status: z.enum(["all", "todo", "in_progress", "in_review", "done", "closed"]).optional().describe("Deprecated status argument.")
 };
 var claimTasksDeprecatedSchema = {
   channel: z.string().describe("Deprecated channel argument."),
@@ -48,7 +48,7 @@ var unclaimTaskDeprecatedSchema = {
 var updateTaskStatusDeprecatedSchema = {
   channel: z.string().describe("Deprecated channel argument."),
   task_number: z.number().describe("Deprecated task number."),
-  status: z.enum(["todo", "in_progress", "in_review", "done"]).describe("Deprecated status argument.")
+  status: z.enum(["todo", "in_progress", "in_review", "done", "closed"]).describe("Deprecated status argument.")
 };
 var DEPRECATED_MCP_TOOL_DEFINITIONS = [
   {
@@ -1087,7 +1087,7 @@ ${formatted}${footer}`
     "List all tasks in a channel. Returns each task's number, title, status, assignee, and message ID. Use this to see what work exists before claiming. Tasks marked as legacy are from an older system and cannot be claimed or modified.",
     {
       channel: z2.string().describe("The channel whose task board to view \u2014 e.g. '#engineering', '#proj-slock'"),
-      status: z2.enum(["all", "todo", "in_progress", "in_review", "done"]).default("all").describe("Filter by status (default: all)")
+      status: z2.enum(["all", "todo", "in_progress", "in_review", "done", "closed"]).default("all").describe("Filter by status (default: all)")
     },
     async ({ channel, status }) => {
       try {
@@ -1311,11 +1311,11 @@ ${lines.join("\n")}${threadHint}`
   );
   server.tool(
     "update_task_status",
-    "Update a task's progress status. You must be the task's assignee to update it. Use in_review when your work is ready for human validation. Only set done for trivial tasks or after explicit approval. Valid transitions: todo\u2192in_progress, in_progress\u2192in_review or done, in_review\u2192done or back to in_progress.",
+    "Update a task's progress status. You must be the task's assignee to update it. Use in_review when your work is ready for human validation. Only set done for trivial tasks or after explicit approval. Use closed to mark a task as won't-do (cancelled / abandoned / out-of-scope) \u2014 distinct from done. Valid transitions: todo\u2192{in_progress,closed}, in_progress\u2192{in_review,done,closed}, in_review\u2192{done,in_progress,closed}, done\u2192{todo,in_progress,in_review,closed}, closed\u2192todo (reopen).",
     {
       channel: z2.string().describe("The channel \u2014 e.g. '#engineering'"),
       task_number: z2.number().describe("The task number to update (e.g. 3)"),
-      status: z2.enum(["todo", "in_progress", "in_review", "done"]).describe("The new status")
+      status: z2.enum(["todo", "in_progress", "in_review", "done", "closed"]).describe("The new status")
     },
     async ({ channel, task_number, status }) => {
       try {

package/dist/{chunk-Q4XUZB34.js → chunk-FG5JGA67.js}

@@ -2558,8 +2558,8 @@ function runCursorModelsCommand() {
 }
 
 // src/drivers/gemini.ts
-import { spawn as spawn5 } from "child_process";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "fs";
+import { execFileSync as execFileSync2, spawn as spawn5 } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import path7 from "path";
 function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
@@ -2568,6 +2568,71 @@ function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   }
   return spawnEnv;
 }
+function normalizeExecOutput2(raw) {
+  return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
+}
+function buildGeminiArgs(config) {
+  const args = [
+    "--output-format",
+    "stream-json",
+    "--yolo",
+    // Gemini CLI headless mode is selected by -p/--prompt. Keep the actual
+    // prompt off argv and feed it through stdin below; this avoids Windows
+    // cmd.exe's 8191-character command-line limit and keeps long wake payloads
+    // below CreateProcess argv pressure too.
+    "-p",
+    ""
+  ];
+  if (config.model && config.model !== "default") {
+    args.push("--model", config.model);
+  }
+  if (config.sessionId) {
+    args.push("--resume", config.sessionId);
+  }
+  return args;
+}
+function resolveGeminiSpawn(commandArgs, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
+  }
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
+  const env = deps.env ?? process.env;
+  const winPath = path7.win32;
+  let geminiEntry = null;
+  try {
+    const globalRoot = normalizeExecOutput2(execFileSyncFn("npm", ["root", "-g"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env
+    })).trim();
+    const candidate = winPath.join(globalRoot, "@google", "gemini-cli", "bundle", "gemini.js");
+    if (existsSyncFn(candidate)) geminiEntry = candidate;
+  } catch {
+  }
+  if (!geminiEntry) {
+    try {
+      const cmdPath = normalizeExecOutput2(execFileSyncFn("where.exe", ["gemini"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env
+      })).trim().split(/\r?\n/)[0];
+      const candidate = winPath.join(winPath.dirname(cmdPath), "node_modules", "@google", "gemini-cli", "bundle", "gemini.js");
+      if (existsSyncFn(candidate)) geminiEntry = candidate;
+    } catch {
+    }
+  }
+  if (!geminiEntry) {
+    throw new Error(
+      "Cannot resolve Gemini CLI entry point on Windows. Ensure @google/gemini-cli is installed globally via npm (npm i -g @google/gemini-cli)."
+    );
+  }
+  return {
+    command: process.execPath,
+    args: [geminiEntry, ...commandArgs]
+  };
+}
 var GeminiDriver = class {
   id = "gemini";
   lifecycle = {
@@ -2597,26 +2662,15 @@ var GeminiDriver = class {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
     this.writeGeminiSettings(ctx);
-    const args = [
-      "--output-format",
-      "stream-json",
-      "--yolo",
-      "-p",
-      ctx.prompt
-    ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
-    }
-    if (ctx.config.sessionId) {
-      args.push("--resume", ctx.config.sessionId);
-    }
+    const { command, args } = resolveGeminiSpawn(buildGeminiArgs(ctx.config));
     const spawnEnv = buildGeminiSpawnEnv(ctx);
-    const proc = spawn5("gemini", args, {
+    const proc = spawn5(command, args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
-      shell: process.platform === "win32"
+      shell: false
     });
+    proc.stdin?.end(ctx.prompt);
     return { process: proc };
   }
   parseLine(line) {
@@ -2718,7 +2772,7 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
@@ -2783,7 +2837,7 @@ var KimiDriver = class {
     const systemPromptPath = path8.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
     const agentFilePath = path8.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     const mcpConfigPath = path8.join(ctx.workingDirectory, KIMI_MCP_FILE);
-    if (!isResume || !existsSync5(systemPromptPath)) {
+    if (!isResume || !existsSync6(systemPromptPath)) {
       writeFileSync6(systemPromptPath, ctx.prompt, "utf8");
     }
     writeFileSync6(agentFilePath, [
@@ -2972,6 +3026,14 @@ var SLOCK_AGENT_NAME = "slock";
 var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
 var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
 var MIN_SUPPORTED_OPENCODE_VERSION = "1.14.30";
+var OPENCODE_PROVIDER_LABELS = {
+  opencode: "OpenCode",
+  "opencode-go": "OpenCode Go",
+  openai: "OpenAI",
+  openrouter: "OpenRouter",
+  deepseek: "DeepSeek",
+  fusecode: "FuseCode"
+};
 function buildChatBridgeCommand(ctx) {
   const isTsSource = ctx.chatBridgePath.endsWith(".ts");
   return [
@@ -3118,12 +3180,62 @@ function parseOpenCodeModelsOutput(output) {
     seen.add(line);
     models.push({
       id: line,
-      label: line,
+      label: formatOpenCodeModelLabel(line),
       verified: "launchable"
     });
   }
   return models.length > 0 ? { models } : null;
 }
+function formatOpenCodeModelLabel(modelId) {
+  const separatorIndex = modelId.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === modelId.length - 1) return modelId;
+  const providerId = modelId.slice(0, separatorIndex);
+  const modelName = modelId.slice(separatorIndex + 1);
+  const providerLabel = OPENCODE_PROVIDER_LABELS[providerId] || humanizeOpenCodeSegment(providerId);
+  const modelParts = modelName.split("/");
+  const modelLabel = humanizeOpenCodeSegment(modelParts[modelParts.length - 1] || modelName);
+  if (modelParts.length === 1) return `${modelLabel} \xB7 ${providerLabel}`;
+  const upstreamLabel = modelParts.slice(0, -1).map(humanizeOpenCodeSegment).join(" / ");
+  return `${modelLabel} \xB7 ${upstreamLabel} via ${providerLabel}`;
+}
+function humanizeOpenCodeSegment(value) {
+  return value.replace(/\[(\d+)m\]/gi, "-$1m").split(/[-_]/).filter(Boolean).map(formatOpenCodeLabelToken).join(" ");
+}
+function formatOpenCodeLabelToken(token) {
+  const normalized = token.toLowerCase();
+  const specialCases = {
+    ai: "AI",
+    api: "API",
+    b: "B",
+    chatgpt: "ChatGPT",
+    claude: "Claude",
+    codestral: "Codestral",
+    deepseek: "DeepSeek",
+    flash: "Flash",
+    free: "Free",
+    gemini: "Gemini",
+    glm: "GLM",
+    gpt: "GPT",
+    hy3: "HY3",
+    kimi: "Kimi",
+    m: "M",
+    minimax: "MiniMax",
+    nano: "Nano",
+    nemotron: "Nemotron",
+    omni: "Omni",
+    opus: "Opus",
+    pro: "Pro",
+    sonnet: "Sonnet",
+    super: "Super"
+  };
+  if (specialCases[normalized]) return specialCases[normalized];
+  if (/^v\d+(\.\d+)?$/.test(normalized)) return normalized.toUpperCase();
+  if (/^\d+m$/i.test(token)) return token.toUpperCase();
+  if (/^\d+[bk]$/i.test(token)) return token.toUpperCase();
+  if (/^m\d+(\.\d+)?$/i.test(token)) return token.toUpperCase();
+  if (/^\d/.test(token)) return token;
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
 function detectOpenCodeModels(home = os4.homedir(), runCommand = runOpenCodeModelsCommand) {
   const commandResult = runCommand(home);
   if (commandResult.error || commandResult.status !== 0) return null;
@@ -4183,6 +4295,66 @@ function isMissingResumeSession(ap) {
   }
   return false;
 }
+function classifyActivityDetailForTrace(detail) {
+  if (!detail) return void 0;
+  if (detail === "Message received") return "message_received";
+  if (detail === "Starting\u2026") return "starting";
+  if (detail === "Running command\u2026") return "running_command";
+  if (detail === "Checking messages\u2026") return "checking_messages";
+  if (detail === "Compacting context") return "compacting_context";
+  if (detail === "Context compaction finished") return "compaction_finished";
+  if (detail === "Context compaction still running; no finish event observed") return "compaction_stale";
+  if (detail === "Idle" || detail === "Process idle") return "idle";
+  if (detail.startsWith("Restarting stalled ") && detail.endsWith(" runtime for queued message")) return "stalled_recovery";
+  if (detail.startsWith("Runtime stalled: no runtime events for ")) return "runtime_stalled";
+  return "other";
+}
+function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
+  const context = [];
+  if (ap.lastActivityDetail) {
+    context.push(`after ${ap.lastActivityDetail}`);
+  }
+  if (ap.driver.busyDeliveryMode === "gated") {
+    context.push(`phase=${ap.gatedSteering.phase}`);
+  }
+  if (ap.gatedSteering.outstandingToolUses > 0) {
+    context.push(`tools=${ap.gatedSteering.outstandingToolUses}`);
+  }
+  if (ap.gatedSteering.compacting) {
+    context.push("compacting");
+  }
+  if (ap.inbox.length > 0) {
+    context.push(`queued=${ap.inbox.length}`);
+  }
+  const detail = [
+    `Runtime stalled: no runtime events for ${staleForMinutes}m`,
+    context.length > 0 ? ` (${context.join(", ")})` : ""
+  ].join("");
+  return {
+    detail,
+    traceAttrs: {
+      ageMs: staleForMs,
+      staleForMinutes,
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      sessionIdPresent: Boolean(ap.sessionId),
+      inboxCount: ap.inbox.length,
+      pendingNotificationCount: ap.pendingNotificationCount,
+      processPidPresent: typeof ap.process.pid === "number",
+      busyDeliveryMode: ap.driver.busyDeliveryMode,
+      supportsStdinNotification: ap.driver.supportsStdinNotification,
+      gatedPhase: ap.driver.busyDeliveryMode === "gated" ? ap.gatedSteering.phase : void 0,
+      outstandingToolUses: ap.gatedSteering.outstandingToolUses,
+      compacting: ap.gatedSteering.compacting,
+      recentStderrCount: ap.recentStderr.length,
+      recentStdoutCount: ap.recentStdout.length
+    }
+  };
+}
 function getMessageDeliveryText(driver) {
   return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
 }
@@ -5855,17 +6027,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (staleForMs < RUNTIME_PROGRESS_STALE_MS) return false;
     ap.runtimeProgressStaleSince = Date.now();
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
-      ageMs: staleForMs,
-      staleForMinutes,
-      lastActivity: ap.lastActivity
-    });
+    const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", diagnostic.traceAttrs);
     this.endRuntimeTrace(ap, "error", {
       outcome: "runtime-stalled",
       ageMs: staleForMs,
-      lastActivity: ap.lastActivity
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail)
     });
-    this.broadcastActivity(agentId, "error", `Runtime stalled: no runtime events for ${staleForMinutes}m`);
+    this.broadcastActivity(agentId, "error", diagnostic.detail);
     return true;
   }
   recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap) {
@@ -5881,10 +6052,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (staleForMs < RUNTIME_PROGRESS_STALE_MS && !ap.runtimeProgressStaleSince) return false;
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     ap.runtimeProgressStaleSince ??= Date.now();
+    const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
     this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
-      ageMs: staleForMs,
-      staleForMinutes,
-      lastActivity: ap.lastActivity,
+      ...diagnostic.traceAttrs,
       pendingMessages: ap.inbox.length,
       recovery: "terminate_for_queued_message"
     });
@@ -5892,6 +6062,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       outcome: "runtime-stalled",
       ageMs: staleForMs,
       lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
       pendingMessages: ap.inbox.length,
       recovery: "terminate_for_queued_message"
     });
@@ -6658,6 +6830,7 @@ function acquireDaemonMachineLock(options) {
 import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
 import path13 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
 var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
   "serverId",
@@ -6674,14 +6847,25 @@ var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
 var LocalRotatingTraceSink = class {
   traceDir;
   maxFileBytes;
+  maxFileAgeMs;
   maxFiles;
+  nowMsProvider;
   currentFile = null;
+  currentFileOpenedAtMs = null;
   currentSize = 0;
   sequence = 0;
   constructor(options) {
     this.traceDir = path13.join(options.machineDir, "traces");
     this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
+    const baseAgeMs = Math.max(1e3, Math.floor(options.maxFileAgeMs ?? DEFAULT_MAX_FILE_AGE_MS));
+    const ageJitterMs = Math.max(0, Math.floor(options.maxFileAgeJitterMs ?? 0));
+    this.maxFileAgeMs = baseAgeMs + ageJitterMs;
     this.maxFiles = Math.max(1, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+    this.nowMsProvider = options.nowMsProvider ?? Date.now;
+  }
+  /** Exposed for observability — the effective rotation age after jitter. */
+  getMaxFileAgeMs() {
+    return this.maxFileAgeMs;
   }
   record(span) {
     try {
@@ -6698,13 +6882,16 @@ var LocalRotatingTraceSink = class {
   }
   ensureFile(nextBytes) {
     mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
-    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes) {
+    const nowMs = this.nowMsProvider();
+    const shouldRotateForAge = this.currentFileOpenedAtMs !== null && nowMs - this.currentFileOpenedAtMs >= this.maxFileAgeMs;
+    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes || shouldRotateForAge) {
       this.currentFile = path13.join(
         this.traceDir,
-        `daemon-trace-${safeTimestamp(Date.now())}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
+        `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
       writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync4(this.currentFile).size;
+      this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
     }
   }
@@ -6789,7 +6976,7 @@ function isDiagnosticIdAttr(key) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path14 from "path";
@@ -6918,6 +7105,35 @@ async function uploadWithSignedCapability({
   return { capability, session, uploadResponse };
 }
 
+// src/traceJitter.ts
+import { createHash as createHash2 } from "crypto";
+var INITIAL_UPLOAD_DELAY_SPAN_MS = 3e4;
+var UPLOAD_INTERVAL_JITTER_SPAN_MS = 6e4;
+var MAX_FILE_AGE_JITTER_SPAN_MS = 6e4;
+function computeTraceJitter(lockId) {
+  const seed = createHash2("sha256").update(lockId).digest();
+  return {
+    initialUploadDelayMs: seed.readUInt32BE(0) % INITIAL_UPLOAD_DELAY_SPAN_MS,
+    uploadIntervalJitterMs: seed.readUInt32BE(4) % UPLOAD_INTERVAL_JITTER_SPAN_MS,
+    maxFileAgeJitterMs: seed.readUInt32BE(8) % MAX_FILE_AGE_JITTER_SPAN_MS
+  };
+}
+var NO_JITTER = {
+  initialUploadDelayMs: 0,
+  uploadIntervalJitterMs: 0,
+  maxFileAgeJitterMs: 0
+};
+function bucketDelayMs(delayMs) {
+  if (delayMs < 1e3) return "0-1s";
+  if (delayMs < 5e3) return "1-5s";
+  if (delayMs < 15e3) return "5-15s";
+  if (delayMs < 3e4) return "15-30s";
+  if (delayMs < 6e4) return "30-60s";
+  if (delayMs < 3e5) return "60s-5m";
+  if (delayMs < 6e5) return "5-10m";
+  return "10m+";
+}
+
 // src/traceBundleUpload.ts
 var TRACE_UPLOAD_SCOPE = "daemon-trace-bundle:create";
 var DEFAULT_UPLOAD_INTERVAL_MS = 5 * 60 * 1e3;
@@ -6925,30 +7141,66 @@ var DEFAULT_MIN_FILE_AGE_MS = 60 * 1e3;
 var DEFAULT_MAX_FILES_PER_RUN = 4;
 var DaemonTraceBundleUploader = class {
   options;
-  timer = null;
+  jitter;
+  timers;
+  initialDelayTimer = null;
+  intervalTimer = null;
+  stopped = false;
   constructor(options) {
     this.options = options;
+    this.jitter = options.jitter ?? (options.lockId ? computeTraceJitter(options.lockId) : NO_JITTER);
+    this.timers = options.timers ?? {
+      setTimeout: globalThis.setTimeout.bind(globalThis),
+      setInterval: globalThis.setInterval.bind(globalThis),
+      clearTimeout: globalThis.clearTimeout.bind(globalThis),
+      clearInterval: globalThis.clearInterval.bind(globalThis)
+    };
   }
   start() {
-    if (this.timer) return;
-    void this.uploadOnce();
-    this.timer = setInterval(() => {
-      void this.uploadOnce();
-    }, this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS));
+    if (this.stopped) return;
+    if (this.initialDelayTimer || this.intervalTimer) return;
+    const initialDelayMs = this.jitter.initialUploadDelayMs;
+    this.initialDelayTimer = this.timers.setTimeout(() => {
+      this.initialDelayTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("initial");
+      this.scheduleNextTick();
+    }, initialDelayMs);
   }
   stop() {
-    if (!this.timer) return;
-    clearInterval(this.timer);
-    this.timer = null;
+    this.stopped = true;
+    if (this.initialDelayTimer) {
+      this.timers.clearTimeout(this.initialDelayTimer);
+      this.initialDelayTimer = null;
+    }
+    if (this.intervalTimer) {
+      this.timers.clearTimeout(this.intervalTimer);
+      this.intervalTimer = null;
+    }
   }
-  async uploadOnce() {
+  /**
+   * Drive a single upload pass. `trigger` is surfaced as a span attribute so
+   * we can distinguish startup drain vs steady-state ticks in ScopeDB.
+   */
+  async uploadOnce(trigger = "manual") {
     const files = await this.findUploadCandidates();
     let uploaded = 0;
     for (const file of files.slice(0, this.options.maxFilesPerRun ?? DEFAULT_MAX_FILES_PER_RUN)) {
-      if (await this.uploadFile(file)) uploaded += 1;
+      if (await this.uploadFile(file, trigger)) uploaded += 1;
     }
     return { attempted: files.length, uploaded };
   }
+  scheduleNextTick() {
+    if (this.stopped) return;
+    const baseIntervalMs = this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS);
+    const nextMs = baseIntervalMs + this.jitter.uploadIntervalJitterMs;
+    this.intervalTimer = this.timers.setTimeout(() => {
+      this.intervalTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("interval");
+      this.scheduleNextTick();
+    }, nextMs);
+  }
   async findUploadCandidates() {
     const traceDir = path14.join(this.options.machineDir, "traces");
     let names;
@@ -6975,13 +7227,16 @@ var DaemonTraceBundleUploader = class {
     }
     return candidates;
   }
-  async uploadFile(file) {
+  async uploadFile(file, trigger) {
     const span = this.options.tracer?.startSpan("daemon.bundle.upload", {
       surface: "daemon",
       kind: "producer",
       attrs: {
         file_present: true,
-        worker_url_present: Boolean(this.options.workerUrl)
+        worker_url_present: Boolean(this.options.workerUrl),
+        upload_trigger: trigger,
+        initial_delay_ms_bucket: bucketDelayMs(this.jitter.initialUploadDelayMs),
+        interval_jitter_ms_bucket: bucketDelayMs(this.jitter.uploadIntervalJitterMs)
       }
     });
     try {
@@ -7057,7 +7312,7 @@ var DaemonTraceBundleUploader = class {
   }
 };
 function sha256Hex(body) {
-  return createHash2("sha256").update(body).digest("hex");
+  return createHash3("sha256").update(body).digest("hex");
 }
 function readPositiveIntegerEnv2(name, fallback) {
   const value = process.env[name];
@@ -7067,6 +7322,7 @@ function readPositiveIntegerEnv2(name, fallback) {
 }
 
 // src/core.ts
+var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
   let serverUrl = "";
@@ -7287,11 +7543,18 @@ var DaemonCore = class {
     if (!this.options.localTrace) return false;
     return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
   }
+  resolveTraceJitter() {
+    const lockId = this.machineLock?.lockId;
+    return lockId ? computeTraceJitter(lockId) : NO_JITTER;
+  }
   installLocalTraceSink(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
+    const jitter = this.resolveTraceJitter();
     this.localTraceSink = new LocalRotatingTraceSink({
       machineDir,
       maxFileBytes: this.options.localTraceMaxFileBytes ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_BYTES", 5 * 1024 * 1024),
+      maxFileAgeMs: this.options.localTraceMaxFileAgeMs ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_AGE_MS", 5 * 60 * 1e3),
+      maxFileAgeJitterMs: jitter.maxFileAgeJitterMs,
       maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
     });
     this.tracer = new BasicTracer({
@@ -7302,15 +7565,16 @@ var DaemonCore = class {
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
     if (this.traceBundleUploader) return;
-    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL;
-    if (!workerUrl) return;
+    if (process.env.SLOCK_DAEMON_TRACE_UPLOAD_DISABLED === "1") return;
+    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL;
     this.traceBundleUploader = new DaemonTraceBundleUploader({
       machineDir,
       serverUrl: this.options.serverUrl,
       apiKey: this.options.apiKey,
       workerUrl,
       tracer: this.tracer,
-      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null
+      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null,
+      lockId: this.machineLock?.lockId
     });
     this.traceBundleUploader.start();
   }

package/dist/cli/index.js

@@ -1119,7 +1119,7 @@ function formatTaskStatusUpdated(taskNumber, status) {
 }
 
 // src/commands/task/list.ts
-var VALID_STATUSES = /* @__PURE__ */ new Set(["all", "todo", "in_progress", "in_review", "done"]);
+var VALID_STATUSES = /* @__PURE__ */ new Set(["all", "todo", "in_progress", "in_review", "done", "closed"]);
 function registerTaskListCommand(parent) {
   parent.command("list").description("List tasks in a channel").requiredOption("--channel <target>", "Channel target: '#channel'").option("--status <s>", "Filter: all|todo|in_progress|in_review|done (default: server-side)").action(async (opts) => {
     let ctx;
@@ -1253,7 +1253,7 @@ function registerTaskUnclaimCommand(parent) {
 }
 
 // src/commands/task/update.ts
-var STATUSES = ["todo", "in_progress", "in_review", "done"];
+var STATUSES = ["todo", "in_progress", "in_review", "done", "closed"];
 function registerTaskUpdateCommand(parent) {
   parent.command("update").description("Update task status").requiredOption("--channel <target>", "Channel target: '#channel'").requiredOption("--number <n>", "Task number to update").requiredOption(
     "--status <status>",

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-Q4XUZB34.js";
+} from "./chunk-FG5JGA67.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-Z3PCMYZO.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-Q4XUZB34.js";
+} from "./chunk-FG5JGA67.js";
 import "./chunk-Z3PCMYZO.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.46.0",
+  "version": "0.46.1-staging.20260509070837",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"