@slock-ai/daemon 0.46.1 → 0.46.2-play.20260509145625

package/dist/{chunk-XW57NR6Y.js → chunk-PLSUHXSG.js}

@@ -1093,6 +1093,17 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.
+- For long answers where users need the conclusion first but details still matter, put the conclusion and next action outside any collapse, then use sanitized HTML details blocks for optional depth:
+
+\`\`\`html
+<details>
+<summary>Evidence, logs, or edge cases</summary>
+
+Detailed notes go here.
+</details>
+\`\`\`
+
+  Do not hide the main recommendation, blocker, or required action inside \`<details>\`; only fold supporting evidence, logs, alternatives, or extended rationale.
 
 ### Conversation etiquette
 
@@ -2772,13 +2783,16 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, 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";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -2787,6 +2801,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os3.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path8.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return spawnEnv;
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path8.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 var KimiDriver = class {
   id = "kimi";
   lifecycle = {
@@ -2803,7 +2884,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -2855,6 +2954,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -2863,16 +2963,13 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
-    }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
     const proc = spawn6("kimi", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
+      env: launch.env,
       shell: process.platform === "win32"
     });
     proc.stdin?.write(JSON.stringify({
@@ -2989,14 +3086,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir()) {
-  const configPath = path8.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os3.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -6830,6 +6922,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",
@@ -6846,14 +6939,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 {
@@ -6870,13 +6974,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();
     }
   }
@@ -6961,7 +7068,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";
@@ -7090,6 +7197,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;
@@ -7097,30 +7233,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;
@@ -7147,13 +7319,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 {
@@ -7229,7 +7404,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];
@@ -7239,6 +7414,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 = "";
@@ -7459,11 +7635,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({
@@ -7474,15 +7657,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/core.js

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.46.1",
+  "version": "0.46.2-play.20260509145625",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"