@botiverse/raft-daemon 0.61.1-play.20260618164849 → 0.62.0

package/dist/{chunk-NPNWIWXT.js → chunk-H3G23UPM.js}

@@ -2582,19 +2582,6 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
-// src/authEnv.ts
-var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
-var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
-function scrubDaemonAuthEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  return env;
-}
-function scrubDaemonChildEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  delete env[SLOCK_AGENT_TOKEN_ENV];
-  return env;
-}
-
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -2881,6 +2868,17 @@ function reduceApmStartupTimeoutTermination(state, input) {
     blockedReason: null
   };
 }
+function reduceApmStartupRequestErrorTermination(state) {
+  return {
+    nextState: {
+      ...state,
+      isIdle: false,
+      expectedTerminationReason: "startup_request_error",
+      phase: "error"
+    },
+    shouldTerminate: true
+  };
+}
 function reduceApmGatedFlush(state, input) {
   return {
     nextState: {
@@ -4150,9 +4148,7 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath || cliPath === "__cli") return [];
@@ -4481,7 +4477,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -4916,7 +4912,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -4942,7 +4938,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5187,6 +5183,7 @@ import path6 from "path";
 // src/runtimeTurnState.ts
 var RuntimeTurnState = class {
   currentTurnId = null;
+  pendingTurnId = null;
   /**
    * Post-tool window where the app-server may not yet accept stdin steering.
    * Gate busy-mode delivery until turn/completed or next progress.
@@ -5194,22 +5191,25 @@ var RuntimeTurnState = class {
   steeringGateActive = false;
   reset() {
     this.currentTurnId = null;
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
   get activeTurnId() {
     return this.currentTurnId;
   }
   get canSteerBusy() {
-    return Boolean(this.currentTurnId && !this.steeringGateActive);
+    return Boolean(this.currentTurnId && !this.pendingTurnId && !this.steeringGateActive);
   }
   markTurnStarted(turnId) {
-    if (turnId !== void 0 && turnId !== null) {
-      this.currentTurnId = turnId;
+    const startedTurnId = turnId ?? this.pendingTurnId;
+    if (startedTurnId) {
+      this.currentTurnId = startedTurnId;
     }
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
-  adoptTurnId(turnId) {
-    this.currentTurnId = turnId;
+  noteTurnAccepted(turnId) {
+    this.pendingTurnId = turnId;
   }
   markProgress() {
     this.steeringGateActive = false;
@@ -5219,6 +5219,7 @@ var RuntimeTurnState = class {
   }
   markTurnCompleted() {
     this.currentTurnId = null;
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
 };
@@ -5328,6 +5329,50 @@ function codexNotificationProgressEvent(itemType, payload) {
     payloadBytes: payload === void 0 ? void 0 : payloadBytes(payload)
   };
 }
+function boundedString(value, limit = 1e3) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length <= limit) return trimmed;
+  return `${trimmed.slice(0, limit - 1)}\u2026`;
+}
+function codexNotificationDiagnosticEvent(message) {
+  const params = message.params ?? {};
+  let diagnosticMessage;
+  let details;
+  switch (message.method) {
+    case "configWarning":
+      diagnosticMessage = boundedString(params.summary) ?? boundedString(params.details) ?? "Codex configuration warning";
+      details = boundedString(params.details);
+      break;
+    case "warning":
+      diagnosticMessage = boundedString(params.message) ?? "Codex warning";
+      break;
+    case "guardianWarning":
+      diagnosticMessage = boundedString(params.message) ?? "Codex guardian warning";
+      break;
+    case "deprecationNotice":
+      diagnosticMessage = boundedString(params.summary) ?? boundedString(params.details) ?? "Codex deprecation notice";
+      details = boundedString(params.details);
+      break;
+    default:
+      return null;
+  }
+  const sessionId = codexMessageThreadId(message);
+  const path18 = boundedString(params.path);
+  return {
+    kind: "runtime_diagnostic",
+    severity: "warning",
+    source: "codex_app_server_notification",
+    itemType: message.method,
+    message: diagnosticMessage,
+    ...details ? { details } : {},
+    ...path18 ? { path: path18 } : {},
+    ...params.range !== void 0 ? { range: params.range } : {},
+    payloadBytes: payloadBytes(params),
+    ...sessionId ? { sessionId } : {}
+  };
+}
 function joinReasoningSummaryText(item) {
   const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
   return summary.join("\n").trim();
@@ -5391,11 +5436,11 @@ var CodexEventNormalizer = class {
       }
       const turn = message.result.turn;
       if (turn && typeof turn.id === "string") {
-        this.turnState.adoptTurnId(turn.id);
+        this.turnState.noteTurnAccepted(turn.id);
         return { events };
       }
       if (typeof message.result.turnId === "string") {
-        this.turnState.adoptTurnId(message.result.turnId);
+        this.turnState.noteTurnAccepted(message.result.turnId);
         return { events };
       }
     }
@@ -5439,7 +5484,7 @@ var CodexEventNormalizer = class {
         const turnId = message.params?.turn?.id;
         this.turnState.markTurnStarted(typeof turnId === "string" ? turnId : null);
         events.push({ kind: "thinking", text: "" });
-        break;
+        return { events, turnStarted: true };
       }
       case "item/agentMessage/delta": {
         const delta = message.params?.delta;
@@ -5494,7 +5539,10 @@ var CodexEventNormalizer = class {
       case "warning":
       case "guardianWarning":
       case "deprecationNotice": {
-        events.push(codexNotificationProgressEvent(message.method, message.params));
+        const diagnostic = codexNotificationDiagnosticEvent(message);
+        if (diagnostic) {
+          events.push(diagnostic);
+        }
         break;
       }
       case "item/started":
@@ -5820,6 +5868,8 @@ var CodexDriver = class {
     detectedModelsVerifiedAs: "launchable",
     toLaunchSpec: (modelId) => ({ params: { model: modelId } })
   };
+  startupReadiness = "initial_turn";
+  requiresSessionInitForDelivery = true;
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
   supportsNativeStandingPrompt = true;
@@ -5869,6 +5919,7 @@ var CodexDriver = class {
   pendingThreadRequestId = null;
   pendingThreadRequestMethod = null;
   pendingResumeFallbackParams = null;
+  pendingInitialTurnRequestId = null;
   initialTurnStarted = false;
   normalizer = new CodexEventNormalizer();
   async spawn(ctx) {
@@ -5881,8 +5932,9 @@ var CodexDriver = class {
     this.pendingThreadRequestId = null;
     this.pendingThreadRequestMethod = null;
     this.pendingResumeFallbackParams = null;
+    this.pendingInitialTurnRequestId = null;
     this.initialTurnStarted = false;
-    this.normalizer.reset({ threadId: ctx.config.sessionId || null });
+    this.normalizer.reset();
     const args = ["app-server", "--listen", "stdio://"];
     const { command, args: spawnArgs, shell } = resolveCodexSpawn(args);
     const proc = spawn2(command, spawnArgs, {
@@ -5932,13 +5984,18 @@ var CodexDriver = class {
       this.pendingThreadRequestId = null;
       this.pendingThreadRequestMethod = null;
       this.pendingResumeFallbackParams = null;
-      events.push({ kind: "error", message: message.error?.message || "Codex app-server request failed" });
+      events.push({
+        kind: "error",
+        message: message.error?.message || "Codex app-server request failed",
+        startupRequestMethod: "initialize"
+      });
       return events;
     }
     if (isResponse && message.id === this.pendingThreadRequestId) {
       if (hasJsonRpcField(message, "error")) {
         const errorMessage = message.error?.message || "Codex app-server request failed";
-        const resumeErrorClassification = this.pendingThreadRequestMethod === "thread/resume" ? classifyCodexResumeError(errorMessage) : null;
+        const requestMethod = this.pendingThreadRequestMethod;
+        const resumeErrorClassification = requestMethod === "thread/resume" ? classifyCodexResumeError(errorMessage) : null;
         if (this.pendingResumeFallbackParams && resumeErrorClassification?.kind === "missing_rollout") {
           events.push(resumeErrorClassification.telemetry);
           this.sendThreadRequest("thread/start", this.pendingResumeFallbackParams);
@@ -5948,14 +6005,31 @@ var CodexDriver = class {
         this.pendingThreadRequestId = null;
         this.pendingThreadRequestMethod = null;
         this.pendingResumeFallbackParams = null;
-        events.push({ kind: "error", message: errorMessage });
+        events.push(requestMethod ? { kind: "error", message: errorMessage, startupRequestMethod: requestMethod } : { kind: "error", message: errorMessage });
         return events;
       }
       this.pendingThreadRequestId = null;
       this.pendingThreadRequestMethod = null;
       this.pendingResumeFallbackParams = null;
     }
+    if (isResponse && message.id === this.pendingInitialTurnRequestId) {
+      this.pendingInitialTurnRequestId = null;
+      if (hasJsonRpcField(message, "error")) {
+        events.push({
+          kind: "error",
+          message: message.error?.message || "Codex app-server request failed",
+          startupRequestMethod: "turn/start"
+        });
+      } else {
+        this.pendingInitialPrompt = null;
+      }
+      return events;
+    }
     const result = this.normalizer.normalizeMessage(message);
+    if (result.turnStarted) {
+      this.pendingInitialTurnRequestId = null;
+      this.pendingInitialPrompt = null;
+    }
     if (result.threadReady) {
       this.startInitialTurn();
     }
@@ -5964,10 +6038,7 @@ var CodexDriver = class {
   get currentSessionId() {
     return this.normalizer.threadId;
   }
-  encodeStdinMessage(text, sessionId, opts) {
-    if (!this.normalizer.threadId && sessionId) {
-      this.normalizer.adoptThreadId(sessionId);
-    }
+  encodeStdinMessage(text, _sessionId, opts) {
     if (!this.normalizer.threadId) return null;
     const mode = opts?.mode || "busy";
     if (mode === "busy") {
@@ -6008,11 +6079,10 @@ var CodexDriver = class {
     return this.requestId;
   }
   startInitialTurn() {
-    if (this.initialTurnStarted || !this.pendingInitialPrompt || !this.normalizer.threadId) return;
+    if (this.initialTurnStarted || this.pendingInitialTurnRequestId !== null || !this.pendingInitialPrompt || !this.normalizer.threadId) return;
     this.initialTurnStarted = true;
     const prompt = this.pendingInitialPrompt;
-    this.pendingInitialPrompt = null;
-    this.sendRequest("turn/start", {
+    this.pendingInitialTurnRequestId = this.sendRequest("turn/start", {
       threadId: this.normalizer.threadId,
       input: [{ type: "text", text: prompt }]
     });
@@ -6514,11 +6584,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -6574,7 +6644,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync6;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path7.win32;
   let geminiEntry = null;
   try {
@@ -6711,15 +6781,12 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 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_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 {
@@ -6728,73 +6795,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os4.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 scrubDaemonChildEnv(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 ?? os4.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) {
-      writeFileSync3(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
-  };
-}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -6818,25 +6818,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    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
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -6860,23 +6842,21 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -6884,7 +6864,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -6997,9 +6977,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os4.homedir()) {
+  const configPath = path8.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -7723,7 +7708,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -10270,6 +10255,63 @@ function closeSatisfiedTurnBoundary(ap, expectedTermination) {
   if (ap.runtime.descriptor.turnBoundary === "process_exit") return true;
   return !ap.runtimeTraceSpan;
 }
+function isStartupRequestErrorEvent(event) {
+  return event.kind === "error" && !!event.startupRequestMethod;
+}
+function runtimeDiagnosticTitle(event) {
+  switch (event.itemType) {
+    case "configWarning":
+      return "Codex config warning";
+    case "guardianWarning":
+      return "Codex guardian warning";
+    case "deprecationNotice":
+      return "Codex deprecation notice";
+    default:
+      return "Codex warning";
+  }
+}
+function summarizeDiagnosticRange(range) {
+  if (range === void 0 || range === null) return null;
+  try {
+    const json = JSON.stringify(range);
+    if (!json) return null;
+    return json.length <= 300 ? json : `${json.slice(0, 299)}\u2026`;
+  } catch {
+    return null;
+  }
+}
+function runtimeDiagnosticTrajectoryEntry(event) {
+  const lines = [event.message];
+  if (event.details && event.details !== event.message) {
+    lines.push(event.details);
+  }
+  if (event.path) {
+    lines.push(`Path: ${event.path}`);
+  }
+  const range = summarizeDiagnosticRange(event.range);
+  if (range) {
+    lines.push(`Range: ${range}`);
+  }
+  return {
+    kind: "system",
+    title: runtimeDiagnosticTitle(event),
+    text: lines.join("\n")
+  };
+}
+function runtimeDiagnosticTraceAttrs(event) {
+  return {
+    kind: event.kind,
+    severity: event.severity,
+    source: event.source,
+    itemType: event.itemType,
+    payloadBytes: event.payloadBytes,
+    message_present: Boolean(event.message),
+    details_present: Boolean(event.details),
+    path_present: Boolean(event.path),
+    range_present: event.range !== void 0,
+    session_id_present: Boolean(event.sessionId)
+  };
+}
 function currentErrorCandidates(ap) {
   return [
     ap.runtimeErrorSinceProgress ? ap.lastRuntimeError : null,
@@ -11193,6 +11235,23 @@ var AgentProcessManager = class _AgentProcessManager {
       clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
     });
   }
+  recordRuntimeDiagnosticActivity(agentId, ap, event) {
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity: ap.lastActivity || "online",
+      detail: ap.lastActivityDetail || "",
+      entries: [runtimeDiagnosticTrajectoryEntry(event)],
+      launchId: ap.launchId || void 0,
+      clientSeq: this.nextActivityClientSeq(agentId)
+    });
+    this.recordDaemonTrace("daemon.runtime.diagnostic", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      ...runtimeDiagnosticTraceAttrs(event)
+    });
+  }
   recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
     const span = this.tracer.startSpan(name, {
       parent: parseTraceparent(parentTraceparent),
@@ -11258,6 +11317,13 @@ var AgentProcessManager = class _AgentProcessManager {
       session_id_present: Boolean(sessionId)
     });
   }
+  initialAgentProcessSessionId(driver, config) {
+    if (driver.requiresSessionInitForDelivery) return null;
+    return config.sessionId || null;
+  }
+  restartSafeSessionId(ap) {
+    return ap.sessionId || (ap.driver.requiresSessionInitForDelivery ? ap.config.sessionId || null : null);
+  }
   sameWakeMessage(left, right) {
     if (!left || !right) return left === right;
     if (left.message_id && right.message_id) return left.message_id === right.message_id;
@@ -11302,16 +11368,18 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     const previousLaunchId = ap.launchId;
     const nextLaunchId = start.launchId || ap.launchId || null;
-    const nextSessionId = ap.sessionId || start.config.sessionId || null;
+    const requiresSessionInit = ap.driver.requiresSessionInitForDelivery === true;
+    const nextSessionId = ap.sessionId || (requiresSessionInit ? null : start.config.sessionId || null);
+    const nextConfigSessionId = nextSessionId || (requiresSessionInit ? start.config.sessionId || null : ap.config.sessionId || start.config.sessionId || null);
     ap.launchId = nextLaunchId;
     ap.sessionId = nextSessionId;
     ap.config = {
       ...start.config,
-      sessionId: nextSessionId
+      sessionId: nextConfigSessionId
     };
     this.idleAgentConfigs.set(agentId, {
-      config: this.buildRestartSafeConfig(ap.config, nextSessionId),
-      sessionId: nextSessionId,
+      config: this.buildRestartSafeConfig(ap.config, nextConfigSessionId),
+      sessionId: nextConfigSessionId,
       launchId: nextLaunchId
     });
     this.recordStartRebind(agentId, start, reason, previousLaunchId, nextLaunchId, nextSessionId);
@@ -11706,12 +11774,14 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         agentCredentialKey: effectiveConfig.agentCredentialKey,
         agentCredentialId: effectiveConfig.agentCredentialId
       };
+      const initialSessionId = this.initialAgentProcessSessionId(driver, liveProcessConfig);
+      const restartSessionId = initialSessionId || (driver.requiresSessionInitForDelivery ? liveProcessConfig.sessionId || null : null);
       agentProcess = {
         runtime,
         driver,
         inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
         config: liveProcessConfig,
-        sessionId: liveProcessConfig.sessionId || null,
+        sessionId: initialSessionId,
         launchId: effectiveLaunchId,
         startupWakeMessage: wakeMessage,
         startupUnreadSummary: unreadSummary,
@@ -11719,6 +11789,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         notifications: new RuntimeNotificationState(),
         activityHeartbeat: null,
         startupTimeoutTimer: null,
+        startupReadinessSatisfied: false,
         compactionWatchdog: null,
         compactionStartedAt: null,
         runtimeProgress: new RuntimeProgressState(Date.now()),
@@ -11744,8 +11815,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
       this.idleAgentConfigs.set(agentId, {
-        config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
-        sessionId: runtimeConfig.sessionId || null,
+        config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
+        sessionId: restartSessionId,
         launchId: effectiveLaunchId
       });
       if (pendingStartRebind) {
@@ -11853,11 +11924,12 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           const finalSignal = ap.exitSignal ?? signal;
           const expectedTerminationReason = ap.gatedSteering.expectedTerminationReason;
           const startupTimeoutTermination = expectedTerminationReason === "startup_timeout";
+          const startupRequestErrorTermination = expectedTerminationReason === "startup_request_error";
           const expectedTermination = Boolean(expectedTerminationReason);
           const stickyTerminalFailureDetail = classifyStickyTerminalFailure(ap);
           const turnBoundarySatisfied = closeSatisfiedTurnBoundary(ap, expectedTermination);
           const closeBeforeTurnBoundary = !turnBoundarySatisfied;
-          const processEndedCleanly = !stickyTerminalFailureDetail && !startupTimeoutTermination && (finalCode === 0 && turnBoundarySatisfied || expectedTermination && !ap.lastRuntimeError);
+          const processEndedCleanly = !stickyTerminalFailureDetail && !startupTimeoutTermination && !startupRequestErrorTermination && (finalCode === 0 && turnBoundarySatisfied || expectedTermination && !ap.lastRuntimeError);
           const terminalFailureDetail = processEndedCleanly ? null : stickyTerminalFailureDetail ?? classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
           const shouldColdStartResumeSession = resumeRecoveryReason !== null;
@@ -11966,13 +12038,16 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             } else if (startupTimeoutTermination) {
               this.cacheStartupTimeoutRetryConfig(agentId, ap);
               logger.warn(`[Agent ${agentId}] Startup timeout cleanup completed (${reason})`);
+            } else if (startupRequestErrorTermination) {
+              this.idleAgentConfigs.delete(agentId);
+              logger.warn(`[Agent ${agentId}] Startup request failure cleanup completed (${reason})`);
             } else {
               this.idleAgentConfigs.delete(agentId);
               logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
             }
             if (terminalFailureDetail) {
-              if (!startupTimeoutTermination) {
+              if (!startupTimeoutTermination && !startupRequestErrorTermination) {
                 this.broadcastActivity(
                   agentId,
                   "error",
@@ -11981,7 +12056,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
                   ap.launchId
                 );
               }
-            } else {
+            } else if (!startupRequestErrorTermination) {
               this.broadcastActivity(agentId, "offline", `Crashed (${summary})`, [], ap.launchId);
             }
           }
@@ -12100,10 +12175,11 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     });
   }
   cacheStartupTimeoutRetryConfig(agentId, ap) {
-    const retryConfig = this.buildRestartSafeConfig(ap.config, ap.sessionId);
+    const retrySessionId = this.restartSafeSessionId(ap);
+    const retryConfig = this.buildRestartSafeConfig(ap.config, retrySessionId);
     this.idleAgentConfigs.set(agentId, {
       config: retryConfig,
-      sessionId: ap.sessionId,
+      sessionId: retrySessionId,
       launchId: ap.launchId
     });
     this.recordDaemonTrace("daemon.agent.startup_timeout.retry_config_cached", {
@@ -14090,11 +14166,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     clearTimeout(ap.startupTimeoutTimer);
     ap.startupTimeoutTimer = null;
   }
+  runtimeStartupReadinessSatisfiedByEvent(ap, event) {
+    if ((ap.driver.startupReadiness ?? "first_event") !== "initial_turn") {
+      return true;
+    }
+    return event.kind !== "session_init" && event.kind !== "internal_progress" && event.kind !== "runtime_diagnostic";
+  }
   handleRuntimeStartupTimeout(agentId, ap, timeoutMs) {
     const current = this.agents.get(agentId);
     if (current !== ap) return;
     const reduction = reduceApmStartupTimeoutTermination(ap.gatedSteering, {
-      hasRuntimeProgressEvent: Boolean(ap.runtimeProgress.lastEventKind)
+      hasRuntimeProgressEvent: ap.startupReadinessSatisfied
     });
     if (!reduction.shouldTerminate) {
       this.clearRuntimeStartupTimeout(ap);
@@ -14122,7 +14204,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
-    logger.warn(`[Agent ${agentId}] ${ap.driver.id} did not emit a startup runtime event within ${timeoutMs}ms; terminating process`);
+    logger.warn(`[Agent ${agentId}] ${ap.driver.id} did not reach startup readiness within ${timeoutMs}ms; terminating process`);
     this.broadcastActivity(agentId, "error", detail, [{ kind: "text", text: `Error: ${detail}` }], ap.launchId);
     this.sendAgentStatus(agentId, "inactive", ap.launchId);
     this.cacheStartupTimeoutRetryConfig(agentId, ap);
@@ -14134,6 +14216,63 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       logger.warn(`[Agent ${agentId}] Failed to terminate startup-timed-out ${ap.driver.id} process: ${reason}`);
     }
   }
+  handleRuntimeStartupRequestError(agentId, ap, event) {
+    const current = this.agents.get(agentId);
+    if (current !== ap) return;
+    this.clearRuntimeStartupTimeout(ap);
+    this.interruptCompactionIfActive(agentId);
+    this.interruptReviewIfActive(agentId);
+    this.flushPendingTrajectory(agentId);
+    const reduction = reduceApmStartupRequestErrorTermination(ap.gatedSteering);
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "startup_request_error" });
+    ap.lastRuntimeError = event.message;
+    ap.runtimeErrorSinceProgress = true;
+    ap.runtimeProgress.markStale();
+    ap.notifications.clearPending();
+    ap.notifications.clearTimer();
+    const diagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);
+    const visibleErrorMessage = diagnostics.spanAttrs.runtime_error_action_required === true ? formatRuntimeLoginRequiredMessage(ap.driver.id) : event.message;
+    const failureAttrs = {
+      turn_outcome: "failed",
+      turn_subtype: "runtime_start_failed",
+      turn_reason: "startup_request_error",
+      runtime_start_failure_kind: "startup_request_error",
+      startup_request_method: event.startupRequestMethod,
+      ...diagnostics.eventAttrs
+    };
+    this.noteRuntimeTraceCounter(ap, event);
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", {
+      kind: event.kind,
+      startup_request_method: event.startupRequestMethod
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.start.request_failed", failureAttrs);
+    this.endRuntimeTrace(ap, "error", {
+      ...failureAttrs,
+      ...diagnostics.spanAttrs,
+      ...runtimeTraceCounterAttrs(ap),
+      ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
+    });
+    logger.warn(
+      `[Agent ${agentId}] ${ap.driver.id} startup request ${event.startupRequestMethod} failed; terminating unusable runtime process`
+    );
+    this.broadcastActivity(agentId, "error", visibleErrorMessage, [
+      { kind: "text", text: `Error: ${visibleErrorMessage}` }
+    ], ap.launchId);
+    this.sendAgentStatus(agentId, "inactive", ap.launchId);
+    this.idleAgentConfigs.delete(agentId);
+    try {
+      this.runtimeExitTraceAttrs.set(ap.runtime, {
+        stop_source: "startup_request_error",
+        expectedTerminationReason: "startup_request_error",
+        startup_request_method: event.startupRequestMethod,
+        runtime_error_class: diagnostics.spanAttrs.runtime_error_class
+      });
+      void ap.runtime.stop({ signal: "SIGTERM", reason: "startup_request_error" });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.warn(`[Agent ${agentId}] Failed to terminate startup-failed ${ap.driver.id} process: ${reason}`);
+    }
+  }
   isThinkingBlockMutationError(message) {
     return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message) || /messages\.\d+\.content\.\d+\.text\.start_timestamp:\s*Extra inputs are not permitted/i.test(message);
   }
@@ -14227,16 +14366,23 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       if (ap) this.recordRuntimeTelemetry(agentId, ap, event);
       return;
     }
+    if (ap && isStartupRequestErrorEvent(event)) {
+      this.handleRuntimeStartupRequestError(agentId, ap, event);
+      return;
+    }
     if (ap) {
       const wasStalled = ap.runtimeProgress.isStale;
-      this.clearRuntimeStartupTimeout(ap);
+      if (this.runtimeStartupReadinessSatisfiedByEvent(ap, event)) {
+        ap.startupReadinessSatisfied = true;
+        this.clearRuntimeStartupTimeout(ap);
+      }
       this.noteRuntimeTraceCounter(ap, event);
       const eventAttrs = event.kind === "internal_progress" ? {
         kind: event.kind,
         source: event.source,
         itemType: event.itemType,
         payloadBytes: event.payloadBytes
-      } : { kind: event.kind };
+      } : event.kind === "runtime_diagnostic" ? runtimeDiagnosticTraceAttrs(event) : { kind: event.kind };
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", eventAttrs);
       if (wasStalled) {
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
@@ -14257,6 +14403,12 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         });
         return;
       }
+      if (event.kind === "runtime_diagnostic") {
+        this.noteRuntimeProgress(ap, event.kind);
+        this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
+        this.recordRuntimeDiagnosticActivity(agentId, ap, event);
+        return;
+      }
       this.noteRuntimeProgress(ap, event.kind);
     } else if (event.kind !== "internal_progress") {
       this.recordDaemonTrace("daemon.agent.event.received_without_process", {
@@ -15973,7 +16125,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["agentId", "event_kind", "runtime"]
   }
 };
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -16009,9 +16161,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -16048,7 +16200,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-MX4RLAAQ.js");
+  await import("./dist-DSRBN3VD.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -16925,8 +17077,6 @@ var DaemonCore = class {
 
 export {
   subscribeDaemonLogs,
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,

package/dist/cli/index.js

@@ -19688,6 +19688,7 @@ function formatAgentProfile(profile) {
     `- Display Name: ${profile.displayName ?? "(none)"}`,
     `- Description: ${profile.description ?? "(none)"}`,
     `- Status: ${profile.status}`,
+    `- Role: ${profile.serverRole}`,
     `- Runtime: ${getRuntimeDisplayName(profile.runtime)}`,
     `- Model: ${profile.model}`,
     `- Reasoning: ${profile.reasoningEffort ?? "medium"}`

package/dist/core.js

@@ -1,5 +1,4 @@
 import {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -11,11 +10,9 @@ import {
   resolveWorkspaceDirectoryPath,
   runBundledSlockCli,
   scanWorkspaceDirectories,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs
-} from "./chunk-NPNWIWXT.js";
+} from "./chunk-H3G23UPM.js";
 export {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -27,6 +24,5 @@ export {
   resolveWorkspaceDirectoryPath,
   runBundledSlockCli,
   scanWorkspaceDirectories,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs
 };

package/dist/{dist-MX4RLAAQ.js → dist-DSRBN3VD.js}

@@ -19409,6 +19409,7 @@ function formatAgentProfile(profile) {
     `- Display Name: ${profile.displayName ?? "(none)"}`,
     `- Description: ${profile.description ?? "(none)"}`,
     `- Status: ${profile.status}`,
+    `- Role: ${profile.serverRole}`,
     `- Runtime: ${getRuntimeDisplayName(profile.runtime)}`,
     `- Model: ${profile.model}`,
     `- Reasoning: ${profile.reasoningEffort ?? "medium"}`

package/dist/index.js

@@ -2,13 +2,11 @@
 import {
   DAEMON_CLI_USAGE,
   DaemonCore,
-  parseDaemonCliArgs,
-  scrubDaemonAuthEnv
-} from "./chunk-NPNWIWXT.js";
+  parseDaemonCliArgs
+} from "./chunk-H3G23UPM.js";
 
 // src/index.ts
-var parsedArgs = parseDaemonCliArgs(process.argv.slice(2), process.env);
-scrubDaemonAuthEnv(process.env);
+var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));
 if (!parsedArgs) {
   console.error(DAEMON_CLI_USAGE);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.61.1-play.20260618164849",
+  "version": "0.62.0",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",