@botiverse/raft-daemon 1.0.6 → 1.0.8

package/dist/{chunk-33F5EBC3.js → chunk-56EVMMRV.js}

@@ -1,6 +1,6 @@
 // src/core.ts
-import path23 from "path";
-import os8 from "os";
+import path25 from "path";
+import os11 from "os";
 import { randomUUID as randomUUID9 } from "crypto";
 import { createRequire as createRequire3 } from "module";
 import { accessSync, createReadStream as createReadStream4, createWriteStream as createWriteStream2 } from "fs";
@@ -1974,16 +1974,16 @@ var KNOWN_TOOL_ALIASES = {
   collab_tool_call: "collab_tool_call"
 };
 var MCP_CHAT_NAMESPACE_PREFIXES = ["mcp__chat__", "mcp_chat_"];
-function normalizeToolLookupName(toolName) {
+function normalizeToolLookupName(toolName2) {
   for (const prefix of MCP_CHAT_NAMESPACE_PREFIXES) {
-    if (toolName.startsWith(prefix)) {
-      return toolName.slice(prefix.length);
+    if (toolName2.startsWith(prefix)) {
+      return toolName2.slice(prefix.length);
     }
   }
-  return toolName;
+  return toolName2;
 }
-function stripToolNamespace(toolName) {
-  const normalized = normalizeToolLookupName(toolName);
+function stripToolNamespace(toolName2) {
+  const normalized = normalizeToolLookupName(toolName2);
   return normalized.replace(/^mcp__\w+__/, "");
 }
 function truncateLabel(text, max = 20) {
@@ -1997,8 +1997,8 @@ function formatTaskNumbers(value) {
 function asObject(input) {
   return input && typeof input === "object" ? input : null;
 }
-function resolveToolSemantic(toolName) {
-  const normalized = normalizeToolLookupName(toolName);
+function resolveToolSemantic(toolName2) {
+  const normalized = normalizeToolLookupName(toolName2);
   return KNOWN_TOOL_ALIASES[normalized] ?? null;
 }
 function tokenizeShellCommand(command) {
@@ -2114,8 +2114,8 @@ function readOptionValue(args, flag) {
 function parsePositiveIntegers(args, flag) {
   return readOptionValues(args, flag).map((value) => Number(value)).filter((value) => Number.isFinite(value) && Number.isInteger(value) && value > 0);
 }
-function resolveSlockCliInvocation(toolName, input) {
-  if (resolveToolSemantic(toolName) !== "bash") return null;
+function resolveSlockCliInvocation(toolName2, input) {
+  if (resolveToolSemantic(toolName2) !== "bash") return null;
   const value = asObject(input);
   if (!value || typeof value.command !== "string") return null;
   const tokens = tokenizeShellCommand(value.command);
@@ -2129,7 +2129,7 @@ function resolveSlockCliInvocation(toolName, input) {
   if (isShellExecutableToken(tokens[firstExecutableIndex])) {
     const innerCommand = unwrapShellPayload(tokens, firstExecutableIndex);
     if (innerCommand) {
-      return resolveSlockCliInvocation(toolName, { command: innerCommand });
+      return resolveSlockCliInvocation(toolName2, { command: innerCommand });
     }
   }
   const executableIndex = findSlockExecutableIndex(tokens);
@@ -2242,16 +2242,16 @@ function resolveSlockCliInvocation(toolName, input) {
       return null;
   }
 }
-function normalizeToolDisplayInvocation(toolName, input) {
-  return resolveSlockCliInvocation(toolName, input) ?? { toolName, input };
+function normalizeToolDisplayInvocation(toolName2, input) {
+  return resolveSlockCliInvocation(toolName2, input) ?? { toolName: toolName2, input };
 }
-function getToolActivityLabel(toolName) {
-  const semantic = resolveToolSemantic(toolName);
+function getToolActivityLabel(toolName2) {
+  const semantic = resolveToolSemantic(toolName2);
   if (semantic) return TOOL_DISPLAY_METADATA[semantic].activityLabel;
-  return `Using ${truncateLabel(stripToolNamespace(toolName))}\u2026`;
+  return `Using ${truncateLabel(stripToolNamespace(toolName2))}\u2026`;
 }
-function summarizeToolInput(toolName, input) {
-  const semantic = resolveToolSemantic(toolName);
+function summarizeToolInput(toolName2, input) {
+  const semantic = resolveToolSemantic(toolName2);
   const value = asObject(input);
   if (!semantic || !value) return "";
   switch (TOOL_DISPLAY_METADATA[semantic].summaryKind) {
@@ -2842,6 +2842,7 @@ var agentApiIntegrationAppUpdateBodySchema = passthroughObject({
   clientKey: z3.string().trim().min(1),
   name: optionalStringSchema,
   description: optionalStringSchema,
+  category: z3.string().trim().min(1).optional(),
   homepageUrl: optionalStringSchema,
   returnUrl: optionalStringSchema,
   agentManifestUrl: optionalStringSchema,
@@ -3290,7 +3291,7 @@ var agentApiReminderResponseSchema = passthroughObject({
 var agentApiReminderLogResponseSchema = passthroughObject({
   events: z3.array(agentApiReminderEventSummarySchema)
 });
-var agentApiMigrationStateSchema = z3.enum(["provisioning", "prep", "ready", "in_transit", "arriving", "completed", "aborted", "failed"]);
+var agentApiMigrationStateSchema = z3.enum(["provisioning", "prep", "ready", "in_transit", "arriving", "starting", "completed", "aborted", "failed"]);
 var agentApiMigrationSummarySchema = passthroughObject({
   id: z3.string(),
   agentId: z3.string(),
@@ -4242,6 +4243,20 @@ var RAFT_OAUTH_SCOPES_SUPPORTED = Object.keys(RAFT_OAUTH_SCOPE_CATALOG);
 var RAFT_OAUTH_DEFAULT_ALLOWED_SCOPES = RAFT_OAUTH_SCOPES_SUPPORTED.filter((scope) => RAFT_OAUTH_SCOPE_CATALOG[scope].defaultAllowed);
 var RAFT_OAUTH_PUBLIC_DISCOVERY_SCOPES = RAFT_OAUTH_SCOPES_SUPPORTED.filter((scope) => RAFT_OAUTH_SCOPE_CATALOG[scope].publicDiscovery);
 
+// ../shared/src/oauthClientCategories.ts
+var OAUTH_CLIENT_CATEGORIES = [
+  "AI & Automation",
+  "Communication",
+  "Productivity & Collaboration",
+  "Developer Tools",
+  "Data & Analytics",
+  "Business Ops",
+  "Infrastructure",
+  "Content & Creative",
+  "Other"
+];
+var OAUTH_CLIENT_CATEGORY_SET = new Set(OAUTH_CLIENT_CATEGORIES);
+
 // ../shared/src/testing/failpoints.ts
 var NoopFailpointRegistry = class {
   get enabled() {
@@ -4565,16 +4580,20 @@ var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", abbreviation: "CC", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", abbreviation: "CX", binary: "codex", supported: true },
+  { id: "grok", displayName: "Grok Build", abbreviation: "GK", binary: "grok", supported: true },
   { id: "builtin", displayName: "Built-in Pi", abbreviation: "BP", binary: "", supported: true },
   { id: "antigravity", displayName: "Antigravity CLI", abbreviation: "AG", binary: "agy", supported: true },
   // Kimi: prefer the in-process SDK (`kimi-sdk` → "Kimi Code") for new agents.
   // The legacy `kimi` (kimi-cli child-process) entry stays for backward compat
   // with existing `runtime=kimi` agents but is labelled deprecated.
   { id: "kimi-sdk", displayName: "Kimi Code", abbreviation: "KC", binary: "", supported: true },
-  { id: "kimi", displayName: "Kimi CLI (deprecated)", abbreviation: "KL", binary: "kimi", supported: true },
+  { id: "kimi", displayName: "Kimi CLI (deprecated)", abbreviation: "KL", binary: "kimi", supported: true, deprecated: true },
   { id: "copilot", displayName: "Copilot CLI", abbreviation: "CP", binary: "copilot", supported: true },
   { id: "cursor", displayName: "Cursor CLI", abbreviation: "CU", binary: "cursor-agent", supported: true },
-  { id: "gemini", displayName: "Gemini CLI", abbreviation: "GM", binary: "gemini", supported: true },
+  // Gemini CLI: deprecated — no longer maintained upstream, replaced by
+  // Antigravity CLI (`antigravity` → "Antigravity CLI"). Kept for backward
+  // compat with existing `runtime=gemini` agents but hidden from selectors.
+  { id: "gemini", displayName: "Gemini CLI (deprecated)", abbreviation: "GM", binary: "gemini", supported: true, deprecated: true },
   { id: "opencode", displayName: "OpenCode", abbreviation: "OC", binary: "opencode", supported: true },
   { id: "pi", displayName: "Pi", abbreviation: "PI", binary: "pi", supported: true }
 ];
@@ -4629,6 +4648,20 @@ var RUNTIME_MODELS = {
     { id: "gpt-5-codex", label: "GPT-5 Codex" },
     { id: "gpt-5", label: "GPT-5" }
   ],
+  grok: [
+    {
+      id: "grok-4.5",
+      label: "Grok 4.5",
+      supportedReasoningEfforts: ["high", "medium", "low"],
+      defaultReasoningEffort: "high",
+      verified: "launchable"
+    },
+    {
+      id: "grok-composer-2.5-fast",
+      label: "Composer 2.5",
+      verified: "launchable"
+    }
+  ],
   antigravity: [
     { id: "default", label: "AGY configured default", verified: "suggestion_only" }
   ],
@@ -5010,12 +5043,12 @@ var TRIAL_END_DATE = /* @__PURE__ */ new Date("2026-06-23T12:00:00Z");
 var TRIAL_DURATION_DAYS = (TRIAL_END_DATE.getTime() - TRIAL_START_DATE.getTime()) / (24 * 60 * 60 * 1e3);
 
 // src/agentProcessManager.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
 import { createHash as createHash3, randomUUID as randomUUID6 } from "crypto";
-import path14 from "path";
+import path16 from "path";
 import { gzipSync } from "zlib";
-import os6 from "os";
+import os9 from "os";
 
 // src/proxy.ts
 import { HttpsProxyAgent } from "https-proxy-agent";
@@ -5231,10 +5264,10 @@ var ChatBridgeToolTimeoutError = class extends Error {
   target;
   timeoutMs;
   durationMs;
-  constructor(toolName, target, timeoutMs, durationMs) {
-    super(`${toolName} timed out after ${timeoutMs}ms${target ? ` (target: ${target})` : ""}`);
+  constructor(toolName2, target, timeoutMs, durationMs) {
+    super(`${toolName2} timed out after ${timeoutMs}ms${target ? ` (target: ${target})` : ""}`);
     this.name = "ChatBridgeToolTimeoutError";
-    this.toolName = toolName;
+    this.toolName = toolName2;
     this.target = target;
     this.timeoutMs = timeoutMs;
     this.durationMs = durationMs;
@@ -5245,7 +5278,7 @@ function describeError(err) {
   return String(err);
 }
 async function executeJsonRequest(url, init, {
-  toolName,
+  toolName: toolName2,
   target = null,
   timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   fetchImpl,
@@ -5269,12 +5302,12 @@ async function executeJsonRequest(url, init, {
     const durationMs = now() - startedAt;
     if (timeoutController.signal.aborted && !init.signal?.aborted) {
       warn(
-        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+        `[ChatBridgeTimeout] tool=${toolName2} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
       );
-      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+      throw new ChatBridgeToolTimeoutError(toolName2, target, timeoutMs, durationMs);
     }
     warn(
-      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+      `[ChatBridgeError] tool=${toolName2} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
     );
     throw err;
   } finally {
@@ -5282,7 +5315,7 @@ async function executeJsonRequest(url, init, {
   }
 }
 async function executeResponseRequest(url, init, {
-  toolName,
+  toolName: toolName2,
   target = null,
   timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   fetchImpl,
@@ -5305,12 +5338,12 @@ async function executeResponseRequest(url, init, {
     const durationMs = now() - startedAt;
     if (timeoutController.signal.aborted && !init.signal?.aborted) {
       warn(
-        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+        `[ChatBridgeTimeout] tool=${toolName2} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
       );
-      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+      throw new ChatBridgeToolTimeoutError(toolName2, target, timeoutMs, durationMs);
     }
     warn(
-      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+      `[ChatBridgeError] tool=${toolName2} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
     );
     throw err;
   } finally {
@@ -5319,8 +5352,8 @@ async function executeResponseRequest(url, init, {
 }
 
 // src/directUploadCapability.ts
-function joinUrl(base, path24) {
-  return `${base.replace(/\/+$/, "")}${path24}`;
+function joinUrl(base, path26) {
+  return `${base.replace(/\/+$/, "")}${path26}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -9252,7 +9285,7 @@ function codexNotificationDiagnosticEvent(message) {
       return null;
   }
   const sessionId = codexMessageThreadId(message);
-  const path24 = boundedString(params.path);
+  const path26 = boundedString(params.path);
   return {
     kind: "runtime_diagnostic",
     severity: "warning",
@@ -9260,7 +9293,7 @@ function codexNotificationDiagnosticEvent(message) {
     itemType: message.method,
     message: diagnosticMessage,
     ...details ? { details } : {},
-    ...path24 ? { path: path24 } : {},
+    ...path26 ? { path: path26 } : {},
     ...params.range !== void 0 ? { range: params.range } : {},
     payloadBytes: payloadBytes(params),
     ...sessionId ? { sessionId } : {}
@@ -9625,13 +9658,13 @@ var CodexEventNormalizer = class {
             break;
           case "mcpToolCall":
             if (isStarted) {
-              const toolName = codexMcpToolName(item);
+              const toolName2 = codexMcpToolName(item);
               this.turnState.markProgress();
-              events.push({ kind: "tool_call", name: toolName, input: item.arguments });
+              events.push({ kind: "tool_call", name: toolName2, input: item.arguments });
             }
             if (isCompleted) {
-              const toolName = codexMcpToolName(item);
-              events.push({ kind: "tool_output", name: toolName });
+              const toolName2 = codexMcpToolName(item);
+              events.push({ kind: "tool_output", name: toolName2 });
               this.turnState.markToolBoundary();
             }
             break;
@@ -10557,153 +10590,1009 @@ function detectCodexModels(home = resolveCodexHomeRootFromEnv()) {
   return { models, default: defaultModel };
 }
 
-// src/drivers/antigravity.ts
-import { randomUUID } from "crypto";
-import { spawn as spawn3 } from "child_process";
-var DEFAULT_PRINT_TIMEOUT = "30m";
-var ANTIGRAVITY_ENV_OVERRIDES = {
-  // `agy` switches to a separate file-based token store when it detects an SSH
-  // session. Daemon agents commonly run under SSH-managed hosts, while the
-  // human login lives in the normal local Antigravity credential store.
-  SSH_CLIENT: void 0,
-  SSH_CONNECTION: void 0,
-  SSH_TTY: void 0
-};
-function resolveAntigravitySpawn(commandArgs, deps = {}) {
-  const command = resolveCommandOnPath("agy", deps) ?? "agy";
+// src/drivers/grok.ts
+import { execFileSync as execFileSync3, spawn as spawn3 } from "child_process";
+import os5 from "os";
+
+// src/drivers/grokHome.ts
+import os4 from "os";
+import path8 from "path";
+function nonEmptyString3(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveGrokHomeFromEnv(env = process.env, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const configured = nonEmptyString3(env.GROK_HOME);
+  if (configured) return path8.resolve(cwd, configured);
+  const homeDir = opts.homeDir ?? env.HOME ?? env.USERPROFILE ?? os4.homedir();
+  return path8.join(homeDir, ".grok");
+}
+
+// src/drivers/grokEventNormalizer.ts
+var TERMINAL_TOOL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function parseGrokJsonRpcLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function nonEmptyString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function payloadBytes3(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function internalProgress(itemType, payload) {
   return {
-    command,
-    args: commandArgs,
-    shell: requiresWindowsShell(command, deps.platform)
+    kind: "internal_progress",
+    source: "grok_acp_notification",
+    itemType,
+    payloadBytes: payloadBytes3(payload)
   };
 }
-function buildAntigravityArgs(ctx) {
-  const args = [
-    "--print",
-    "--print-timeout",
-    runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config)).envVars?.ANTIGRAVITY_PRINT_TIMEOUT || DEFAULT_PRINT_TIMEOUT,
-    "--dangerously-skip-permissions"
-  ];
-  if (ctx.config.sessionId) {
-    args.push("--continue");
+function toolName(update, fallback = "tool") {
+  const meta = recordValue(update._meta);
+  const tool = recordValue(meta?.["x.ai/tool"]);
+  return nonEmptyString4(tool?.name) ?? nonEmptyString4(update.name) ?? nonEmptyString4(update.title) ?? fallback;
+}
+function parseAccumulatedArguments(value) {
+  if (!value) return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return { arguments: value };
   }
-  return args;
 }
-var ERROR_LINE_PREFIX_RE = /^(?:(?:error|fatal|exception|failure):\s*|failed(?:\b|:))/i;
-var ERROR_LINE_PATTERNS = [
-  /authentication timed out/i,
-  /\bpermission denied\b/i,
-  /\bunauthorized\b/i,
-  /\brate limit(?:ed)?\b/i,
-  /\bserver error\b/i,
-  /\bnetwork error\b/i,
-  /\brequest timed out\b/i,
-  /\btimed out waiting\b/i,
-  /\b(?:http|status)\s+(?:401|403|429|500|502|503|504)\b/i
-];
-function isErrorLine(line) {
-  return ERROR_LINE_PREFIX_RE.test(line) || ERROR_LINE_PATTERNS.some((pattern) => pattern.test(line));
+function numericUsageAttrs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const source = value;
+  const mappings = [
+    ["inputTokens", "input_tokens"],
+    ["outputTokens", "output_tokens"],
+    ["totalTokens", "total_tokens"],
+    ["cachedReadTokens", "cached_read_tokens"],
+    ["reasoningTokens", "reasoning_tokens"],
+    ["modelCalls", "model_calls"],
+    ["apiDurationMs", "api_duration_ms"],
+    ["numTurns", "num_turns"]
+  ];
+  const attrs = {};
+  for (const [wireKey, attrKey] of mappings) {
+    const candidate = source[wireKey];
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      attrs[attrKey] = candidate;
+    }
+  }
+  return attrs;
 }
-var AntigravityDriver = class {
-  id = "antigravity";
-  lifecycle = {
-    kind: "per_turn",
-    start: "immediate",
-    exit: "natural",
-    inFlightWake: "spawn_new"
-  };
-  communication = {
-    chat: "slock_cli",
-    runtimeControl: "none"
-  };
-  session = {
-    recovery: "resume_or_fresh"
-  };
-  model = {
-    detectedModelsVerifiedAs: "suggestion_only",
-    toLaunchSpec: (_modelId) => ({ args: [] })
-  };
-  supportsStdinNotification = false;
-  busyDeliveryMode = "none";
-  sessionId = null;
-  sessionAnnounced = false;
-  probe() {
-    const command = resolveCommandOnPath("agy");
-    if (!command) return { available: false };
-    return {
-      available: true,
-      version: readCommandVersion(command) ?? void 0
-    };
+var GrokEventNormalizer = class {
+  sessionIdValue = null;
+  nextTurnGeneration = 0;
+  activeTurnGeneration = null;
+  completedTurnGenerations = /* @__PURE__ */ new Set();
+  generationByPromptId = /* @__PURE__ */ new Map();
+  promptIdsByGeneration = /* @__PURE__ */ new Map();
+  toolCalls = /* @__PURE__ */ new Map();
+  toolCallIdsByIndex = /* @__PURE__ */ new Map();
+  reset() {
+    this.sessionIdValue = null;
+    this.nextTurnGeneration = 0;
+    this.activeTurnGeneration = null;
+    this.completedTurnGenerations.clear();
+    this.generationByPromptId.clear();
+    this.promptIdsByGeneration.clear();
+    this.toolCalls.clear();
+    this.toolCallIdsByIndex.clear();
+  }
+  get sessionId() {
+    return this.sessionIdValue;
   }
-  async spawn(ctx) {
-    this.sessionId = ctx.config.sessionId || randomUUID();
-    this.sessionAnnounced = false;
-    const { command, args, shell } = resolveAntigravitySpawn(buildAntigravityArgs(ctx));
-    const { spawnEnv } = await prepareCliTransport(ctx, {
-      NO_COLOR: "1",
-      ...ANTIGRAVITY_ENV_OVERRIDES
-    });
-    const proc = spawn3(command, args, {
-      cwd: ctx.workingDirectory,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
-      shell
-    });
-    proc.stdin?.end(ctx.prompt);
-    return { process: proc };
+  get canSteerBusy() {
+    return this.activeTurnGeneration !== null;
+  }
+  adoptSession(sessionId) {
+    this.sessionIdValue = sessionId;
+  }
+  beginPrompt() {
+    this.nextTurnGeneration += 1;
+    this.activeTurnGeneration = this.nextTurnGeneration;
+    this.toolCalls.clear();
+    this.toolCallIdsByIndex.clear();
+    return this.nextTurnGeneration;
+  }
+  abortPrompt(generation) {
+    if (this.activeTurnGeneration === generation) {
+      this.activeTurnGeneration = null;
+    }
+    this.forgetPromptIdsForGeneration(generation);
+  }
+  normalizeNotification(message) {
+    const params = message.params ?? {};
+    const notificationSessionId = nonEmptyString4(params.sessionId);
+    if (notificationSessionId) {
+      if (!this.sessionIdValue || notificationSessionId !== this.sessionIdValue) return [];
+    }
+    const update = recordValue(params.update);
+    if (!update) {
+      return message.method ? [internalProgress(message.method, params)] : [];
+    }
+    const updateKind = nonEmptyString4(update.sessionUpdate);
+    if (!updateKind) return [internalProgress(message.method ?? "session/update", update)];
+    switch (updateKind) {
+      case "agent_message_chunk": {
+        const content = recordValue(update.content);
+        const text = content?.type === "text" ? content.text : null;
+        return typeof text === "string" && text.length > 0 ? [{ kind: "text", text }] : [internalProgress(updateKind, update)];
+      }
+      case "agent_thought_chunk": {
+        const content = recordValue(update.content);
+        const text = content?.type === "text" ? content.text : null;
+        return typeof text === "string" && text.length > 0 ? [{ kind: "thinking", text }] : [internalProgress(updateKind, update)];
+      }
+      case "tool_call_delta_chunk": {
+        const index = typeof update.tool_index === "number" ? update.tool_index : null;
+        const wireId = nonEmptyString4(update.tool_call_id);
+        if (index !== null && wireId) this.toolCallIdsByIndex.set(index, wireId);
+        const toolCallId = wireId ?? (index !== null ? this.toolCallIdsByIndex.get(index) ?? null : null);
+        if (toolCallId) {
+          const existing = this.toolCalls.get(toolCallId) ?? {
+            name: toolName(update),
+            arguments: "",
+            callEmitted: false,
+            outputEmitted: false
+          };
+          existing.name = toolName(update, existing.name);
+          if (typeof update.arguments_delta === "string") {
+            existing.arguments += update.arguments_delta;
+          }
+          this.toolCalls.set(toolCallId, existing);
+        }
+        return [internalProgress(updateKind, update)];
+      }
+      case "tool_call": {
+        const toolCallId = nonEmptyString4(update.toolCallId) ?? `anonymous-${this.toolCalls.size + 1}`;
+        const existing = this.toolCalls.get(toolCallId) ?? {
+          name: toolName(update),
+          arguments: "",
+          callEmitted: false,
+          outputEmitted: false
+        };
+        existing.name = toolName(update, existing.name);
+        this.toolCalls.set(toolCallId, existing);
+        if (existing.callEmitted) return [internalProgress(updateKind, update)];
+        existing.callEmitted = true;
+        return [{
+          kind: "tool_call",
+          name: existing.name,
+          input: update.rawInput ?? parseAccumulatedArguments(existing.arguments)
+        }];
+      }
+      case "tool_call_update": {
+        const toolCallId = nonEmptyString4(update.toolCallId);
+        const status = nonEmptyString4(update.status);
+        if (!toolCallId || !status || !TERMINAL_TOOL_STATUSES.has(status)) {
+          return [internalProgress(updateKind, update)];
+        }
+        const existing = this.toolCalls.get(toolCallId) ?? {
+          name: toolName(update),
+          arguments: "",
+          callEmitted: false,
+          outputEmitted: false
+        };
+        this.toolCalls.set(toolCallId, existing);
+        if (existing.outputEmitted) return [internalProgress(updateKind, update)];
+        existing.outputEmitted = true;
+        return [{ kind: "tool_output", name: existing.name }];
+      }
+      case "pending_interaction":
+        return [{
+          kind: "runtime_diagnostic",
+          severity: "warning",
+          source: "grok_acp_notification",
+          itemType: updateKind,
+          message: "Grok Build is waiting for user interaction",
+          payloadBytes: payloadBytes3(update),
+          ...this.sessionIdValue ? { sessionId: this.sessionIdValue } : {}
+        }];
+      case "turn_completed": {
+        const promptId = nonEmptyString4(update.prompt_id);
+        const generation = promptId ? this.generationByPromptId.get(promptId) ?? this.activeTurnGeneration : this.activeTurnGeneration;
+        return this.finishPrompt(generation, {
+          stopReason: update.stop_reason,
+          promptId,
+          agentResult: update.agent_result,
+          usage: update.usage
+        });
+      }
+      default:
+        return [internalProgress(updateKind, update)];
+    }
   }
-  parseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed) return [];
+  finishPrompt(generation, completion) {
+    if (generation === null || generation === void 0) return [];
+    const promptId = nonEmptyString4(completion.promptId) ?? void 0;
+    if (promptId) this.rememberPromptGeneration(promptId, generation);
+    if (this.completedTurnGenerations.has(generation)) return [];
+    this.completedTurnGenerations.add(generation);
+    if (this.completedTurnGenerations.size > 32) {
+      const oldest = this.completedTurnGenerations.values().next().value;
+      if (oldest !== void 0) {
+        this.completedTurnGenerations.delete(oldest);
+        this.forgetPromptIdsForGeneration(oldest);
+      }
+    }
+    if (this.activeTurnGeneration === generation) {
+      this.activeTurnGeneration = null;
+    }
+    const stopReason = nonEmptyString4(completion.stopReason) ?? "unknown";
+    const agentResult = nonEmptyString4(completion.agentResult);
     const events = [];
-    if (!this.sessionAnnounced && this.sessionId) {
-      events.push({ kind: "session_init", sessionId: this.sessionId });
-      this.sessionAnnounced = true;
+    const usageAttrs = numericUsageAttrs(completion.usage);
+    if (Object.keys(usageAttrs).length > 0) {
+      events.push({
+        kind: "telemetry",
+        name: "token_usage",
+        source: "grok_acp",
+        usageKind: "per_turn",
+        ...this.sessionIdValue ? { sessionId: this.sessionIdValue } : {},
+        ...promptId ? { turnId: promptId } : {},
+        attrs: usageAttrs
+      });
     }
-    if (isErrorLine(trimmed)) {
-      events.push({ kind: "error", message: trimmed });
-      return events;
+    if (stopReason === "error") {
+      events.push({ kind: "error", message: agentResult ?? "Grok Build turn failed" });
+    } else if (stopReason === "cancelled") {
+      events.push({ kind: "error", message: agentResult ?? "Grok Build turn was cancelled" });
     }
-    events.push({ kind: "text", text: line });
+    events.push({ kind: "turn_end", ...this.sessionIdValue ? { sessionId: this.sessionIdValue } : {} });
+    this.toolCalls.clear();
+    this.toolCallIdsByIndex.clear();
     return events;
   }
-  encodeStdinMessage(_text, _sessionId, _opts) {
-    return null;
-  }
-  buildSystemPrompt(config, _agentId) {
-    return buildCliTransportSystemPrompt(config, {
-      extraCriticalRules: [],
-      postStartupNotes: [
-        "**Antigravity runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
-      ],
-      includeStdinNotificationSection: false,
-      messageNotificationStyle: "poll"
-    });
+  rememberPromptGeneration(promptId, generation) {
+    const existingGeneration = this.generationByPromptId.get(promptId);
+    if (existingGeneration !== void 0) return;
+    this.generationByPromptId.set(promptId, generation);
+    const promptIds = this.promptIdsByGeneration.get(generation) ?? /* @__PURE__ */ new Set();
+    promptIds.add(promptId);
+    this.promptIdsByGeneration.set(generation, promptIds);
   }
-  async detectModels() {
-    return null;
+  forgetPromptIdsForGeneration(generation) {
+    const promptIds = this.promptIdsByGeneration.get(generation);
+    if (!promptIds) return;
+    for (const promptId of promptIds) {
+      if (this.generationByPromptId.get(promptId) === generation) {
+        this.generationByPromptId.delete(promptId);
+      }
+    }
+    this.promptIdsByGeneration.delete(generation);
   }
 };
 
-// src/drivers/copilot.ts
-import { spawn as spawn4 } from "child_process";
-async function buildCopilotSpawnEnv(ctx) {
-  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+// src/drivers/grok.ts
+var GROK_AGENT_ARGS = ["agent", "--no-leader", "--always-approve", "stdio"];
+var GROK_AGENT_PROBE_ARGS = ["agent", "stdio", "--help"];
+var GROK_INTERJECT_METHOD = "_x.ai/interject";
+var KNOWN_REASONING_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max", "ultra"]);
+function hasJsonRpcField2(message, field) {
+  return Object.prototype.hasOwnProperty.call(message, field);
 }
-var CopilotDriver = class {
-  id = "copilot";
-  lifecycle = {
-    kind: "per_turn",
-    start: "immediate",
-    exit: "natural",
-    inFlightWake: "spawn_new"
+function isJsonRpcResponse2(message) {
+  return message.id !== void 0 && (hasJsonRpcField2(message, "result") || hasJsonRpcField2(message, "error"));
+}
+function isJsonRpcServerRequest(message) {
+  return message.id !== void 0 && typeof message.method === "string" && !isJsonRpcResponse2(message);
+}
+function payloadBytes4(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function nonEmptyString5(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function describeProbeFailure(error) {
+  if (error && typeof error === "object") {
+    const candidate = error;
+    if (typeof candidate.status === "number") return `exit status ${candidate.status}`;
+    if (typeof candidate.signal === "string") return `terminated by ${candidate.signal}`;
+    if (typeof candidate.code === "string") return candidate.code;
+  }
+  return "probe failed";
+}
+function readGrokVersion(command, shell, deps) {
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  try {
+    const output = execFileSyncFn(command, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 5e3,
+      shell
+    });
+    return (Buffer.isBuffer(output) ? output.toString("utf8") : String(output ?? "")).trim().split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+function resolveGrokCommand(deps = {}) {
+  return resolveCommandOnPath("grok", deps);
+}
+function resolveGrokSpawn(args, deps = {}) {
+  const command = resolveGrokCommand(deps);
+  if (!command) {
+    throw new Error("Cannot resolve the Grok Build CLI on PATH. Install Grok Build and run `grok login` first.");
+  }
+  const platform = deps.platform ?? process.platform;
+  return {
+    command,
+    args,
+    shell: requiresWindowsShell(command, platform)
   };
-  communication = {
-    chat: "slock_cli",
-    runtimeControl: "none"
+}
+function probeGrok(deps = {}) {
+  const command = resolveGrokCommand(deps);
+  if (!command) {
+    return { available: false, diagnostic: "No Grok Build CLI was found on PATH." };
+  }
+  const platform = deps.platform ?? process.platform;
+  const shell = requiresWindowsShell(command, platform);
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  try {
+    execFileSyncFn(command, [...GROK_AGENT_PROBE_ARGS], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 5e3,
+      shell
+    });
+  } catch (error) {
+    return {
+      available: false,
+      diagnostic: `Grok Build agent stdio probe failed: ${describeProbeFailure(error)}.`
+    };
+  }
+  return {
+    available: true,
+    version: readGrokVersion(command, shell, deps) ?? void 0
   };
-  session = {
-    recovery: "resume_or_fresh"
+}
+function initializeParams() {
+  return {
+    protocolVersion: 1,
+    clientCapabilities: {
+      fs: { readTextFile: false, writeTextFile: false },
+      terminal: false
+    },
+    _meta: {
+      startupHints: {
+        nonInteractive: true,
+        skipGitStatus: true,
+        skipProjectLayout: true
+      },
+      clientType: "raft-daemon",
+      clientVersion: "1.0.0"
+    }
+  };
+}
+function isCompatibleInitializeResult2(result) {
+  const value = recordValue2(result);
+  const capabilities = recordValue2(value?.agentCapabilities);
+  return value?.protocolVersion === 1 && capabilities?.loadSession === true;
+}
+function initializeFailureMessage() {
+  return "Grok Build ACP initialize response is missing protocolVersion=1 or loadSession support; upgrade Grok Build to a compatible release.";
+}
+function sessionIdFromResult(result, requestedSessionId) {
+  const value = recordValue2(result);
+  if (!value) return requestedSessionId ?? null;
+  const meta = recordValue2(value._meta);
+  return nonEmptyString5(value.sessionId) ?? nonEmptyString5(meta?.sessionId) ?? requestedSessionId ?? null;
+}
+function grokErrorMessage(message, fallback) {
+  return nonEmptyString5(message.error?.message) ?? fallback;
+}
+function isMissingSessionError(error) {
+  if (!error) return false;
+  const code = error.data && typeof error.data === "object" && !Array.isArray(error.data) ? nonEmptyString5(error.data.code) : null;
+  return code === "FS_NOT_FOUND" || /\b(path|session)\b.*\b(not found|missing)\b/i.test(error.message ?? "") || /\bno such file or directory\b/i.test(String(error.data ?? ""));
+}
+function recoveryEvents(requestedSessionId) {
+  return {
+    telemetry: {
+      kind: "telemetry",
+      name: "recovery",
+      source: "grok_resume_missing_session",
+      attrs: {
+        resume_error_class: "missing_session",
+        recovery_action: "fallback_fresh_thread"
+      }
+    },
+    recovery: {
+      kind: "runtime_recovery",
+      source: "grok_resume_missing_session",
+      resumeErrorClass: "missing_session",
+      recoveryAction: "fallback_fresh_thread",
+      message: "Grok Build could not resume its previous session; Raft started a fresh Grok session.",
+      details: "Use Raft conversation history and local MEMORY.md/notes as the recovery point; do not assume prior Grok session context is loaded.",
+      ...requestedSessionId ? { requestedSessionId } : {}
+    }
+  };
+}
+function prependRecoveryNotice(prompt, recovery) {
+  return `${recovery.message}
+
+${recovery.details}
+
+${prompt}`;
+}
+function modelReasoningEfforts(meta) {
+  const value = recordValue2(meta);
+  if (!value) return { efforts: [] };
+  const efforts = [];
+  let defaultEffort;
+  if (Array.isArray(value.reasoningEfforts)) {
+    for (const entry of value.reasoningEfforts) {
+      const entryRecord = recordValue2(entry);
+      const effort = typeof entry === "string" ? nonEmptyString5(entry) : entryRecord ? nonEmptyString5(entryRecord.id) ?? nonEmptyString5(entryRecord.value) : null;
+      if (!effort || !KNOWN_REASONING_EFFORTS.has(effort) || efforts.includes(effort)) continue;
+      efforts.push(effort);
+      if (entryRecord?.default === true) defaultEffort = effort;
+    }
+  }
+  const current = nonEmptyString5(value.reasoningEffort);
+  if (!defaultEffort && current && efforts.includes(current)) defaultEffort = current;
+  return { efforts, ...defaultEffort ? { defaultEffort } : {} };
+}
+function grokModelSetFromInitializeResult(result) {
+  const resultRecord = recordValue2(result);
+  const meta = recordValue2(resultRecord?._meta);
+  const modelState = recordValue2(meta?.modelState);
+  if (!modelState || !Array.isArray(modelState.availableModels)) return null;
+  const models = [];
+  for (const candidate of modelState.availableModels) {
+    const entry = recordValue2(candidate);
+    if (!entry) continue;
+    const id = nonEmptyString5(entry.modelId);
+    if (!id) continue;
+    const { efforts, defaultEffort } = modelReasoningEfforts(entry._meta);
+    models.push({
+      id,
+      label: nonEmptyString5(entry.name) ?? id,
+      verified: "launchable",
+      ...efforts.length > 0 ? { supportedReasoningEfforts: efforts } : {},
+      ...defaultEffort ? { defaultReasoningEffort: defaultEffort } : {}
+    });
+  }
+  if (models.length === 0) return null;
+  const current = nonEmptyString5(modelState.currentModelId);
+  return {
+    models,
+    ...current && models.some((model) => model.id === current) ? { default: current } : {}
+  };
+}
+var GrokDriver = class {
+  id = "grok";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  stdoutChannel = "structured_protocol";
+  session = { recovery: "resume_or_fresh" };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
+  startupReadiness = "initial_turn";
+  requiresSessionInitForDelivery = true;
+  supportsStdinNotification = true;
+  busyDeliveryMode = "direct";
+  supportsNativeStandingPrompt = true;
+  process = null;
+  requestId = 0;
+  initializeRequestId = null;
+  pendingSessionRequestId = null;
+  pendingSessionRequestMethod = null;
+  pendingModelRequestId = null;
+  pendingInitialPrompt = null;
+  pendingDeliveryRequests = /* @__PURE__ */ new Map();
+  requestedResumeSessionId = null;
+  freshSessionParams = null;
+  selectedModel = null;
+  selectedReasoningEffort = null;
+  normalizer = new GrokEventNormalizer();
+  grokHomeRoot = null;
+  get currentSessionId() {
+    return this.normalizer.sessionId;
+  }
+  get currentRuntimeHomeDir() {
+    return this.grokHomeRoot;
+  }
+  probe() {
+    return probeGrok();
+  }
+  async spawn(ctx) {
+    const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    const launchFields = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config));
+    this.process = null;
+    this.requestId = 0;
+    this.initializeRequestId = null;
+    this.pendingSessionRequestId = null;
+    this.pendingSessionRequestMethod = null;
+    this.pendingSessionAfterInitialize = null;
+    this.pendingModelRequestId = null;
+    this.pendingInitialPrompt = ctx.prompt;
+    this.pendingDeliveryRequests.clear();
+    this.requestedResumeSessionId = nonEmptyString5(ctx.config.sessionId);
+    this.selectedModel = launchFields.model === "default" ? null : nonEmptyString5(launchFields.model);
+    this.selectedReasoningEffort = nonEmptyString5(launchFields.reasoningEffort);
+    this.normalizer.reset();
+    this.grokHomeRoot = resolveGrokHomeFromEnv(spawnEnv, {
+      cwd: ctx.workingDirectory,
+      homeDir: spawnEnv.HOME ?? spawnEnv.USERPROFILE ?? os5.homedir()
+    });
+    const meta = {
+      systemPromptOverride: ctx.standingPrompt,
+      yoloMode: true,
+      ...this.selectedModel ? { modelId: this.selectedModel } : {}
+    };
+    this.freshSessionParams = {
+      cwd: ctx.workingDirectory,
+      mcpServers: [],
+      _meta: meta
+    };
+    const sessionRequest = this.requestedResumeSessionId ? {
+      method: "session/load",
+      params: {
+        sessionId: this.requestedResumeSessionId,
+        cwd: ctx.workingDirectory,
+        mcpServers: [],
+        _meta: meta
+      }
+    } : { method: "session/new", params: this.freshSessionParams };
+    const launch = resolveGrokSpawn([...GROK_AGENT_ARGS], { env: spawnEnv });
+    const proc = spawn3(launch.command, launch.args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell: launch.shell
+    });
+    this.process = proc;
+    queueMicrotask(() => {
+      this.pendingSessionAfterInitialize = sessionRequest;
+      this.initializeRequestId = this.sendRequest("initialize", initializeParams());
+    });
+    return { process: proc };
+  }
+  pendingSessionAfterInitialize = null;
+  parseLine(line) {
+    const message = parseGrokJsonRpcLine(line);
+    if (!message) return [];
+    if (isJsonRpcServerRequest(message)) {
+      this.sendErrorResponse(message.id, `Grok ACP client request "${message.method}" is not supported by the non-interactive Raft daemon`);
+      return [];
+    }
+    if (!isJsonRpcResponse2(message)) {
+      return this.normalizer.normalizeNotification(message);
+    }
+    if (message.id === this.initializeRequestId) {
+      this.initializeRequestId = null;
+      if (hasJsonRpcField2(message, "error")) {
+        this.pendingSessionAfterInitialize = null;
+        return [{
+          kind: "error",
+          message: grokErrorMessage(message, "Grok Build ACP initialize failed"),
+          startupRequestMethod: "initialize"
+        }];
+      }
+      if (!isCompatibleInitializeResult2(message.result)) {
+        this.pendingSessionAfterInitialize = null;
+        return [{ kind: "error", message: initializeFailureMessage(), startupRequestMethod: "initialize" }];
+      }
+      if (this.pendingSessionAfterInitialize) {
+        const pending = this.pendingSessionAfterInitialize;
+        this.pendingSessionAfterInitialize = null;
+        this.sendSessionRequest(pending.method, pending.params);
+      }
+      return [];
+    }
+    if (message.id === this.pendingSessionRequestId) {
+      const requestMethod = this.pendingSessionRequestMethod;
+      this.pendingSessionRequestId = null;
+      this.pendingSessionRequestMethod = null;
+      if (hasJsonRpcField2(message, "error")) {
+        if (requestMethod === "session/load" && isMissingSessionError(message.error) && this.freshSessionParams) {
+          const recovery = recoveryEvents(this.requestedResumeSessionId);
+          if (this.pendingInitialPrompt !== null) {
+            this.pendingInitialPrompt = prependRecoveryNotice(this.pendingInitialPrompt, recovery.recovery);
+          }
+          this.sendSessionRequest("session/new", this.freshSessionParams);
+          return [recovery.telemetry, recovery.recovery];
+        }
+        return [{
+          kind: "error",
+          message: grokErrorMessage(message, "Grok Build session initialization failed"),
+          ...requestMethod ? { startupRequestMethod: requestMethod } : {}
+        }];
+      }
+      const sessionId = sessionIdFromResult(message.result, requestMethod === "session/load" ? this.requestedResumeSessionId : null);
+      if (!sessionId) {
+        return [{
+          kind: "error",
+          message: "Grok Build session response did not include a sessionId.",
+          ...requestMethod ? { startupRequestMethod: requestMethod } : {}
+        }];
+      }
+      this.normalizer.adoptSession(sessionId);
+      const modelId = this.selectedModel;
+      if (modelId) {
+        this.pendingModelRequestId = this.sendRequest("session/set_model", {
+          sessionId,
+          modelId,
+          ...this.selectedReasoningEffort ? { _meta: { reasoningEffort: this.selectedReasoningEffort } } : {}
+        });
+        return [];
+      }
+      return this.startInitialPromptAndAnnounceSession(sessionId);
+    }
+    if (message.id === this.pendingModelRequestId) {
+      this.pendingModelRequestId = null;
+      if (hasJsonRpcField2(message, "error")) {
+        return [{
+          kind: "error",
+          message: grokErrorMessage(message, "Grok Build model selection failed"),
+          startupRequestMethod: "session/set_model"
+        }];
+      }
+      const sessionId = this.normalizer.sessionId;
+      return sessionId ? this.startInitialPromptAndAnnounceSession(sessionId) : [{
+        kind: "error",
+        message: "Grok Build model selection completed before the session became ready.",
+        startupRequestMethod: "session/set_model"
+      }];
+    }
+    if (message.id !== void 0 && this.pendingDeliveryRequests.has(message.id)) {
+      const pending = this.pendingDeliveryRequests.get(message.id);
+      this.pendingDeliveryRequests.delete(message.id);
+      if (hasJsonRpcField2(message, "error")) {
+        if (pending.method === "turn/start") this.normalizer.abortPrompt(pending.generation);
+        const errorMessage = grokErrorMessage(message, "Grok Build ACP delivery failed");
+        if (pending.method === "turn/start" && pending.initial) {
+          return [{ kind: "error", message: errorMessage, startupRequestMethod: "session/prompt" }];
+        }
+        return [{
+          kind: "delivery_error",
+          message: errorMessage,
+          requestMethod: pending.method,
+          source: "grok_acp_response",
+          payloadBytes: payloadBytes4(message.error)
+        }];
+      }
+      if (pending.method === "turn/steer") return [];
+      const result = recordValue2(message.result) ?? {};
+      const meta = recordValue2(result._meta) ?? {};
+      return this.normalizer.finishPrompt(pending.generation, {
+        stopReason: result.stopReason,
+        promptId: meta.promptId,
+        agentResult: result.agentResult ?? meta.agentResult,
+        usage: meta.usage ?? meta
+      });
+    }
+    return [];
+  }
+  encodeStdinMessage(text, sessionId, opts) {
+    const liveSessionId = this.normalizer.sessionId ?? nonEmptyString5(sessionId);
+    if (!liveSessionId) return null;
+    if (!this.normalizer.sessionId) this.normalizer.adoptSession(liveSessionId);
+    if ((opts?.mode ?? "busy") === "busy") {
+      if (!this.normalizer.canSteerBusy) return null;
+      const id2 = this.nextRequestId();
+      this.pendingDeliveryRequests.set(id2, { method: "turn/steer" });
+      return JSON.stringify({
+        jsonrpc: "2.0",
+        id: id2,
+        method: GROK_INTERJECT_METHOD,
+        params: {
+          sessionId: liveSessionId,
+          text,
+          interjectionId: `raft-${id2}`
+        }
+      });
+    }
+    const { id, request } = this.buildPromptRequest(text, liveSessionId, false);
+    this.pendingDeliveryRequests.set(id, request);
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method: "session/prompt",
+      params: {
+        sessionId: liveSessionId,
+        prompt: [{ type: "text", text }]
+      }
+    });
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildCliTransportSystemPrompt(config, {
+      extraCriticalRules: [],
+      postStartupNotes: [
+        "**IMPORTANT**: Your process stays alive across turns. While you are working, Raft may write batched inbox-count notifications into the current turn; call `raft message check` at natural breakpoints to read the pending messages."
+      ],
+      includeStdinNotificationSection: true,
+      messageNotificationStyle: "direct"
+    });
+  }
+  async detectModels() {
+    return await detectGrokModelsFromAcp();
+  }
+  nextRequestId() {
+    this.requestId += 1;
+    return this.requestId;
+  }
+  sendRequest(method, params) {
+    const id = this.nextRequestId();
+    this.process?.stdin?.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    return id;
+  }
+  sendErrorResponse(id, message) {
+    this.process?.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message }
+    }) + "\n");
+  }
+  sendSessionRequest(method, params) {
+    this.pendingSessionRequestMethod = method;
+    this.pendingSessionRequestId = this.sendRequest(method, params);
+  }
+  buildPromptRequest(text, sessionId, initial) {
+    const id = this.nextRequestId();
+    const generation = this.normalizer.beginPrompt();
+    return {
+      id,
+      request: { method: "turn/start", generation, initial },
+      wire: {
+        jsonrpc: "2.0",
+        id,
+        method: "session/prompt",
+        params: {
+          sessionId,
+          prompt: [{ type: "text", text }]
+        }
+      }
+    };
+  }
+  startInitialPromptAndAnnounceSession(sessionId) {
+    const prompt = this.pendingInitialPrompt;
+    if (prompt === null) return [];
+    this.pendingInitialPrompt = null;
+    const built = this.buildPromptRequest(prompt, sessionId, true);
+    this.pendingDeliveryRequests.set(built.id, built.request);
+    this.process?.stdin?.write(JSON.stringify(built.wire) + "\n");
+    return [{ kind: "session_init", sessionId }];
+  }
+};
+async function detectGrokModelsFromAcp(options = {}) {
+  const env = withWindowsUserEnvironment(options.env ?? process.env, { env: options.env ?? process.env });
+  let launch;
+  try {
+    launch = resolveGrokSpawn([...GROK_AGENT_ARGS], { env });
+  } catch {
+    return null;
+  }
+  return await new Promise((resolve) => {
+    const proc = spawn3(launch.command, launch.args, {
+      cwd: options.cwd ?? process.cwd(),
+      stdio: ["pipe", "pipe", "ignore"],
+      env,
+      shell: launch.shell
+    });
+    let settled = false;
+    let buffer = "";
+    const initializeRequestId = 1;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearClockTimeout(timer);
+      proc.kill();
+      resolve(result);
+    };
+    const timer = setClockTimeout(() => finish(null), options.timeoutMs ?? 5e3);
+    proc.once("error", () => finish(null));
+    proc.once("exit", () => finish(null));
+    proc.stdout?.on("data", (chunk) => {
+      if (settled) return;
+      buffer += chunk.toString();
+      for (; ; ) {
+        const newline = buffer.indexOf("\n");
+        if (newline === -1) break;
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        const message = parseGrokJsonRpcLine(line);
+        if (!message || !isJsonRpcResponse2(message) || message.id !== initializeRequestId) continue;
+        if (!hasJsonRpcField2(message, "result") || !isCompatibleInitializeResult2(message.result)) {
+          finish(null);
+          return;
+        }
+        finish(grokModelSetFromInitializeResult(message.result));
+        return;
+      }
+    });
+    proc.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id: initializeRequestId,
+      method: "initialize",
+      params: initializeParams()
+    }) + "\n");
+  });
+}
+
+// src/drivers/antigravity.ts
+import { randomUUID } from "crypto";
+import { spawn as spawn4 } from "child_process";
+var DEFAULT_PRINT_TIMEOUT = "30m";
+var ANTIGRAVITY_ENV_OVERRIDES = {
+  // `agy` switches to a separate file-based token store when it detects an SSH
+  // session. Daemon agents commonly run under SSH-managed hosts, while the
+  // human login lives in the normal local Antigravity credential store.
+  SSH_CLIENT: void 0,
+  SSH_CONNECTION: void 0,
+  SSH_TTY: void 0
+};
+function resolveAntigravitySpawn(commandArgs, deps = {}) {
+  const command = resolveCommandOnPath("agy", deps) ?? "agy";
+  return {
+    command,
+    args: commandArgs,
+    shell: requiresWindowsShell(command, deps.platform)
+  };
+}
+function buildAntigravityArgs(ctx) {
+  const args = [
+    "--print",
+    "--print-timeout",
+    runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config)).envVars?.ANTIGRAVITY_PRINT_TIMEOUT || DEFAULT_PRINT_TIMEOUT,
+    "--dangerously-skip-permissions"
+  ];
+  if (ctx.config.sessionId) {
+    args.push("--continue");
+  }
+  return args;
+}
+var ERROR_LINE_PREFIX_RE = /^(?:(?:error|fatal|exception|failure):\s*|failed(?:\b|:))/i;
+var ERROR_LINE_PATTERNS = [
+  /authentication timed out/i,
+  /\bpermission denied\b/i,
+  /\bunauthorized\b/i,
+  /\brate limit(?:ed)?\b/i,
+  /\bserver error\b/i,
+  /\bnetwork error\b/i,
+  /\brequest timed out\b/i,
+  /\btimed out waiting\b/i,
+  /\b(?:http|status)\s+(?:401|403|429|500|502|503|504)\b/i
+];
+function isErrorLine(line) {
+  return ERROR_LINE_PREFIX_RE.test(line) || ERROR_LINE_PATTERNS.some((pattern) => pattern.test(line));
+}
+var AntigravityDriver = class {
+  id = "antigravity";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "suggestion_only",
+    toLaunchSpec: (_modelId) => ({ args: [] })
+  };
+  supportsStdinNotification = false;
+  busyDeliveryMode = "none";
+  sessionId = null;
+  sessionAnnounced = false;
+  probe() {
+    const command = resolveCommandOnPath("agy");
+    if (!command) return { available: false };
+    return {
+      available: true,
+      version: readCommandVersion(command) ?? void 0
+    };
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || randomUUID();
+    this.sessionAnnounced = false;
+    const { command, args, shell } = resolveAntigravitySpawn(buildAntigravityArgs(ctx));
+    const { spawnEnv } = await prepareCliTransport(ctx, {
+      NO_COLOR: "1",
+      ...ANTIGRAVITY_ENV_OVERRIDES
+    });
+    const proc = spawn4(command, args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell
+    });
+    proc.stdin?.end(ctx.prompt);
+    return { process: proc };
+  }
+  parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return [];
+    const events = [];
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    if (isErrorLine(trimmed)) {
+      events.push({ kind: "error", message: trimmed });
+      return events;
+    }
+    events.push({ kind: "text", text: line });
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildCliTransportSystemPrompt(config, {
+      extraCriticalRules: [],
+      postStartupNotes: [
+        "**Antigravity runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
+      ],
+      includeStdinNotificationSection: false,
+      messageNotificationStyle: "poll"
+    });
+  }
+  async detectModels() {
+    return null;
+  }
+};
+
+// src/drivers/copilot.ts
+import { spawn as spawn5 } from "child_process";
+async function buildCopilotSpawnEnv(ctx) {
+  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+}
+var CopilotDriver = class {
+  id = "copilot";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
@@ -10735,7 +11624,7 @@ var CopilotDriver = class {
       args.push(`--resume=${ctx.config.sessionId}`);
     }
     const spawnEnv = await buildCopilotSpawnEnv(ctx);
-    const proc = spawn4("copilot", args, {
+    const proc = spawn5("copilot", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -10827,7 +11716,7 @@ var CopilotDriver = class {
 };
 
 // src/drivers/cursor.ts
-import { spawn as spawn5, spawnSync } from "child_process";
+import { spawn as spawn6, spawnSync } from "child_process";
 async function buildCursorSpawnEnv(ctx, deps = {}) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   return withWindowsUserEnvironment(spawnEnv, deps);
@@ -10871,7 +11760,7 @@ var CursorDriver = class {
     }
     args.push(ctx.prompt);
     const spawnEnv = await buildCursorSpawnEnv(ctx);
-    const proc = spawn5("cursor-agent", args, {
+    const proc = spawn6("cursor-agent", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -10997,9 +11886,9 @@ function runCursorModelsCommand() {
 }
 
 // src/drivers/gemini.ts
-import { execFileSync as execFileSync3, spawn as spawn6 } from "child_process";
+import { execFileSync as execFileSync4, spawn as spawn7 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import path8 from "path";
+import path9 from "path";
 async function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
   const launchEnvVars = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config)).envVars;
@@ -11040,10 +11929,10 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   if (platform !== "win32") {
     return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
   }
-  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync4;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
   const env = deps.env ?? process.env;
-  const winPath = path8.win32;
+  const winPath = path9.win32;
   let geminiEntry = null;
   try {
     const globalRoot = normalizeExecOutput2(execFileSyncFn("npm", ["root", "-g"], {
@@ -11105,7 +11994,7 @@ var GeminiDriver = class {
     this.sessionAnnounced = false;
     const { command, args } = resolveGeminiSpawn(buildGeminiArgs(ctx.config));
     const spawnEnv = await buildGeminiSpawnEnv(ctx);
-    const proc = spawn6(command, args, {
+    const proc = spawn7(command, args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -11178,10 +12067,10 @@ var GeminiDriver = class {
 
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import os4 from "os";
-import path9 from "path";
+import os6 from "os";
+import path10 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";
@@ -11228,8 +12117,8 @@ var KimiDriver = class {
     this.sessionId = ctx.config.sessionId || randomUUID2();
     this.sessionAnnounced = false;
     this.promptRequestId = randomUUID2();
-    const systemPromptPath = path9.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
-    const agentFilePath = path9.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const systemPromptPath = path10.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path10.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     if (!isResume || !existsSync6(systemPromptPath)) {
       writeFileSync3(systemPromptPath, ctx.prompt, "utf8");
     }
@@ -11254,7 +12143,7 @@ var KimiDriver = class {
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
     const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const proc = spawn8(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -11375,8 +12264,8 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
+function detectKimiModels(home = os6.homedir()) {
+  const configPath = path10.join(home, ".kimi", "config.toml");
   let raw;
   try {
     raw = readFileSync3(configPath, "utf8");
@@ -11405,7 +12294,7 @@ function detectKimiModels(home = os4.homedir()) {
 import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter } from "events";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
-import path10 from "path";
+import path11 from "path";
 import { createRequire as createRequire2 } from "module";
 import {
   createKimiHarness,
@@ -11430,7 +12319,7 @@ function createKimiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildKimiSessionDir(workingDirectory) {
-  return path10.join(workingDirectory, KIMI_SESSION_DIR);
+  return path11.join(workingDirectory, KIMI_SESSION_DIR);
 }
 function kimiErrorMessage(error) {
   if (typeof error === "string" && error.trim()) return error.trim();
@@ -11812,7 +12701,7 @@ var KimiSdkRuntimeSession = class {
 };
 function detectKimiSdkModels(home = resolveKimiHome(), ctx = {}) {
   const span = ctx.span;
-  const configPath = path10.join(home, "config.toml");
+  const configPath = path11.join(home, "config.toml");
   const homeFromEnv = Boolean(process.env.KIMI_CODE_HOME);
   const emit2 = (outcome, extra = {}) => {
     span?.addEvent("daemon.kimi_sdk.models.config", {
@@ -11925,10 +12814,10 @@ var KimiSdkDriver = class {
 };
 
 // src/drivers/opencode.ts
-import { spawn as spawn8, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn9, spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import os5 from "os";
-import path11 from "path";
+import os7 from "os";
+import path12 from "path";
 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):";
@@ -11948,8 +12837,8 @@ function parseUserOpenCodeConfig(ctx) {
   const raw = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config)).envVars?.OPENCODE_CONFIG_CONTENT;
   return parseOpenCodeConfigContent(raw);
 }
-function readLocalOpenCodeConfig(home = os5.homedir()) {
-  const configPath = path11.join(home, ".config", "opencode", "opencode.json");
+function readLocalOpenCodeConfig(home = os7.homedir()) {
+  const configPath = path12.join(home, ".config", "opencode", "opencode.json");
   try {
     return parseOpenCodeConfigContent(readFileSync5(configPath, "utf8"));
   } catch {
@@ -12009,7 +12898,7 @@ function mergeOpenCodeConfigs(localConfig, envConfig) {
     }
   };
 }
-function buildOpenCodeConfig(ctx, home = os5.homedir()) {
+function buildOpenCodeConfig(ctx, home = os7.homedir()) {
   const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
   const userAgents = recordField(userConfig.agent);
   const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
@@ -12027,7 +12916,7 @@ function buildOpenCodeConfig(ctx, home = os5.homedir()) {
     mcp: recordField(userConfig.mcp)
   };
 }
-async function buildOpenCodeLaunchOptions(ctx, home = os5.homedir(), version = null) {
+async function buildOpenCodeLaunchOptions(ctx, home = os7.homedir(), version = null) {
   const slock = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   const config = buildOpenCodeConfig(ctx, home);
   const env = {
@@ -12076,7 +12965,7 @@ function parseOpenCodeModelsOutput(output) {
   }
   return models.length > 0 ? { models } : null;
 }
-function detectOpenCodeModels(home = os5.homedir(), runCommand = runOpenCodeModelsCommand) {
+function detectOpenCodeModels(home = os7.homedir(), runCommand = runOpenCodeModelsCommand) {
   const commandResult = runCommand(home);
   if (commandResult.error || commandResult.status !== 0) return null;
   return parseOpenCodeModelsOutput(commandResult.stdout);
@@ -12097,11 +12986,11 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   };
 }
 function isWindowsCommandShim(commandPath) {
-  const ext = path11.win32.extname(commandPath).toLowerCase();
+  const ext = path12.win32.extname(commandPath).toLowerCase();
   return ext === ".cmd" || ext === ".bat";
 }
 function opencodePackageEntryCandidates(packageRoot) {
-  const winPath = path11.win32;
+  const winPath = path12.win32;
   return [
     winPath.join(packageRoot, "bin", "opencode.exe"),
     winPath.join(packageRoot, "bin", "opencode.js"),
@@ -12110,7 +12999,7 @@ function opencodePackageEntryCandidates(packageRoot) {
   ];
 }
 function openCodeSpecForEntry(entry, commandArgs) {
-  if (path11.win32.extname(entry).toLowerCase() === ".exe") {
+  if (path12.win32.extname(entry).toLowerCase() === ".exe") {
     return { command: entry, args: commandArgs, shell: false };
   }
   return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
@@ -12119,7 +13008,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
   const existsSyncFn = deps.existsSyncFn ?? existsSync7;
   const execFileSyncFn = deps.execFileSyncFn;
   const env = deps.env ?? process.env;
-  const winPath = path11.win32;
+  const winPath = path12.win32;
   const candidates = [];
   if (execFileSyncFn) {
     try {
@@ -12147,7 +13036,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
 function extractWindowsShimTargets(commandPath, deps = {}) {
   if (!isWindowsCommandShim(commandPath)) return [];
   const readFileSyncFn = deps.readFileSyncFn ?? readFileSync5;
-  const commandDir = path11.win32.dirname(commandPath);
+  const commandDir = path12.win32.dirname(commandPath);
   let raw;
   try {
     raw = String(readFileSyncFn(commandPath, "utf8"));
@@ -12158,7 +13047,7 @@ function extractWindowsShimTargets(commandPath, deps = {}) {
   const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
   for (const match of raw.matchAll(dp0Pattern)) {
     const relative = match[1]?.replace(/^\\+/, "");
-    if (relative) candidates.push(path11.win32.normalize(path11.win32.join(commandDir, relative)));
+    if (relative) candidates.push(path12.win32.normalize(path12.win32.join(commandDir, relative)));
   }
   return candidates;
 }
@@ -12176,7 +13065,7 @@ function resolveOpenCodeSpawn(commandArgs, deps = {}) {
     };
   }
   const command = resolveCommandOnPath("opencode", deps);
-  if (command && path11.win32.extname(command).toLowerCase() === ".exe") {
+  if (command && path12.win32.extname(command).toLowerCase() === ".exe") {
     return { command, args: commandArgs, shell: false };
   }
   const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
@@ -12282,9 +13171,9 @@ var OpenCodeDriver = class {
     if (unsupportedMessage) {
       throw new Error(unsupportedMessage);
     }
-    const launch = await buildOpenCodeLaunchOptions(ctx, os5.homedir(), version);
+    const launch = await buildOpenCodeLaunchOptions(ctx, os7.homedir(), version);
     const spawnSpec = resolveOpenCodeSpawn(launch.args);
-    const proc = spawn8(spawnSpec.command, spawnSpec.args, {
+    const proc = spawn9(spawnSpec.command, spawnSpec.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: launch.env,
@@ -12350,7 +13239,7 @@ var OpenCodeDriver = class {
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
 import { mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
-import path12 from "path";
+import path13 from "path";
 import {
   createAgentSessionFromServices,
   createAgentSessionServices,
@@ -12363,7 +13252,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 
 // src/drivers/piCommandTool.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 import {
   createBashTool
 } from "@earendil-works/pi-coding-agent";
@@ -12384,7 +13273,7 @@ var POWERSHELL_ARGS = [
 ];
 var MAX_TIMEOUT_SECONDS = 2147483647 / 1e3;
 function killWindowsProcessTree(pid) {
-  const killer = spawn9("taskkill.exe", ["/F", "/T", "/PID", String(pid)], {
+  const killer = spawn10("taskkill.exe", ["/F", "/T", "/PID", String(pid)], {
     detached: true,
     stdio: "ignore",
     windowsHide: true
@@ -12410,7 +13299,7 @@ function buildPiPowerShellScript(command) {
   ].join("\r\n");
 }
 function createPiPowerShellOperations(deps = {}) {
-  const spawnProcess = deps.spawn ?? spawn9;
+  const spawnProcess = deps.spawn ?? spawn10;
   const killProcessTree = deps.killProcessTree ?? killWindowsProcessTree;
   return {
     exec: async (command, cwd, { onData, signal, timeout, env }) => {
@@ -12511,13 +13400,13 @@ function createPiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildPiSessionDir(workingDirectory) {
-  return path12.join(workingDirectory, PI_SESSION_DIR);
+  return path13.join(workingDirectory, PI_SESSION_DIR);
 }
 function buildBuiltInSessionDir(workingDirectory) {
-  return path12.join(workingDirectory, BUILTIN_SESSION_DIR);
+  return path13.join(workingDirectory, BUILTIN_SESSION_DIR);
 }
 function buildBuiltInAgentDir(workingDirectory) {
-  return path12.join(workingDirectory, BUILTIN_AGENT_DIR);
+  return path13.join(workingDirectory, BUILTIN_AGENT_DIR);
 }
 async function buildPiSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
@@ -12631,7 +13520,7 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path12.join(sessionDir, match) : null;
+  return match ? path13.join(sessionDir, match) : null;
 }
 function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
@@ -12912,8 +13801,8 @@ async function createPiAgentSessionForContext(ctx, sessionId, opts = {}) {
     const sessionCreateEnvPatch = buildPiSessionCreateEnvPatch(runtimeConfig, launchRuntimeFields.envVars);
     const services = await withProcessEnvPatch(sessionCreateEnvPatch, async () => {
       const modelRuntime = await ModelRuntime.create({
-        authPath: path12.join(agentDir, "auth.json"),
-        modelsPath: path12.join(agentDir, "models.json"),
+        authPath: path13.join(agentDir, "auth.json"),
+        modelsPath: path13.join(agentDir, "models.json"),
         allowModelNetwork: false
       });
       await seedPiSessionModelRuntime(modelRuntime, runtimeConfig);
@@ -13521,9 +14410,253 @@ var ChildProcessRuntimeSession = class {
       });
     });
   }
-};
-function createChildProcessRuntimeSession(driver, ctx) {
-  return new ChildProcessRuntimeSession(driver, ctx);
+};
+function createChildProcessRuntimeSession(driver, ctx) {
+  return new ChildProcessRuntimeSession(driver, ctx);
+}
+
+// src/drivers/runtimeArtifacts.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync4,
+  statSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import os8 from "os";
+import path14 from "path";
+function allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir) {
+  const roots = [workspaceDir];
+  switch (runtime) {
+    case "claude":
+      roots.push(path14.join(homeDir, ".claude"));
+      break;
+    case "codex":
+      roots.push(homeDir, path14.join(homeDir, ".codex"));
+      break;
+    case "grok":
+      roots.push(homeDir, path14.join(homeDir, ".grok"));
+      break;
+    case "kimi":
+    case "kimi-sdk":
+      roots.push(path14.join(homeDir, ".kimi"));
+      break;
+    case "pi":
+      roots.push(path14.join(homeDir, ".pi"), path14.join(homeDir, ".pi", "agent"));
+      break;
+  }
+  return roots;
+}
+function findSessionJsonl(root, predicate) {
+  let visited = 0;
+  const maxEntries = 1e4;
+  const maxDepth = 8;
+  const visit = (dir, depth) => {
+    if (depth < 0 || visited >= maxEntries) return null;
+    let entries;
+    try {
+      entries = readdirSync4(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (++visited > maxEntries) return null;
+      if (!entry.isFile() || !predicate(entry.name)) continue;
+      return path14.join(dir, entry.name);
+    }
+    for (const entry of entries) {
+      if (++visited > maxEntries) return null;
+      if (!entry.isDirectory()) continue;
+      const found = visit(path14.join(dir, entry.name), depth - 1);
+      if (found) return found;
+    }
+    return null;
+  };
+  return visit(root, maxDepth);
+}
+function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
+  const indexPath = path14.join(homeDir, ".kimi", "session_index.jsonl");
+  try {
+    const index = readFileSync6(indexPath, "utf8");
+    for (const line of index.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.sessionId === sessionId && entry.sessionDir && existsSync8(entry.sessionDir)) {
+          return entry.sessionDir;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const sessionsRoot = path14.join(homeDir, ".kimi", "sessions");
+  try {
+    const prefix = agentId ? `wd_${agentId}_` : "wd_";
+    for (const entry of readdirSync4(sessionsRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
+      const candidate = path14.join(sessionsRoot, entry.name, `session_${sessionId}`);
+      if (existsSync8(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+function findGrokSessionTranscript(root, sessionId) {
+  let visited = 0;
+  const maxEntries = 1e4;
+  const maxDepth = 4;
+  const preferredFiles = ["updates.jsonl", "events.jsonl", "chat_history.jsonl"];
+  const visit = (dir, depth) => {
+    if (depth < 0 || visited >= maxEntries) return null;
+    let entries;
+    try {
+      entries = readdirSync4(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (++visited > maxEntries) return null;
+      if (!entry.isDirectory()) continue;
+      const child = path14.join(dir, entry.name);
+      if (entry.name === sessionId) {
+        for (const filename of preferredFiles) {
+          const candidate = path14.join(child, filename);
+          try {
+            if (statSync(candidate).isFile()) return candidate;
+          } catch {
+          }
+        }
+      }
+      const found = visit(child, depth - 1);
+      if (found) return found;
+    }
+    return null;
+  };
+  return visit(root, maxDepth);
+}
+function findPiSessionFile2(sessionId, workingDirectory, homeDir) {
+  if (workingDirectory) {
+    const piSessionsDir = path14.join(workingDirectory, ".pi-sessions");
+    try {
+      const files = readdirSync4(piSessionsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => ({
+        name: entry.name,
+        path: path14.join(piSessionsDir, entry.name),
+        stat: statSync(path14.join(piSessionsDir, entry.name))
+      })).filter((entry) => entry.stat.isFile() && entry.name.includes(sessionId)).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+      if (files[0]) return files[0].path;
+    } catch {
+    }
+  }
+  const legacyRoots = [path14.join(homeDir, ".pi", "agent"), path14.join(homeDir, ".pi")];
+  for (const root of legacyRoots) {
+    const found = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+    if (found) return found;
+  }
+  return null;
+}
+function safeSessionFilename(value) {
+  const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "unknown-session";
+}
+function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir, join, resolve) {
+  try {
+    const dir = path14.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync4(dir, { recursive: true });
+    const filePath = path14.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    const searchedPaths = resolve?.searchedPaths ?? [];
+    writeFileSync4(filePath, JSON.stringify({
+      type: "runtime_session_handoff",
+      runtime,
+      sessionId,
+      launchId: join?.launchId ?? null,
+      processInstanceId: join?.processInstanceId ?? null,
+      resolveStatus: "transcript_resolve_missing",
+      lookupMethod: resolve?.lookupMethod ?? "none",
+      searchedPaths,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      note: "The native runtime transcript file was not found on this machine; this daemon-created handoff records the runtime session identity + the directories checked for diagnostics."
+    }) + "\n", { mode: 384 });
+    return {
+      label: sessionId,
+      path: filePath,
+      runtime,
+      reachable: true,
+      reason: `native session file path not found; using daemon handoff file; searched=[${searchedPaths.join(", ")}]`
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
+  if (config.runtime === "codex") {
+    return resolveCodexHomeRootFromConfig(config, defaultHomeDir, workspacePath, process.env, opts);
+  }
+  if (config.runtime === "grok") {
+    return resolveGrokHomeFromEnv({ ...process.env, ...config.envVars ?? {} }, {
+      cwd: workspacePath,
+      homeDir: defaultHomeDir
+    });
+  }
+  return defaultHomeDir;
+}
+function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
+  const home = resolveRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts);
+  if (config.runtime === "codex" && opts.agentId) mkdirSync4(home, { recursive: true });
+  return home;
+}
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os8.homedir(), fallbackDir, opts) {
+  let resolvedPath = null;
+  let lookupMethod = "none";
+  const searchedPaths = [];
+  if (runtime === "claude") {
+    lookupMethod = "claude_jsonl";
+    const claudeRoot = path14.join(homeDir, ".claude", "projects");
+    searchedPaths.push(claudeRoot);
+    resolvedPath = findSessionJsonl(claudeRoot, (filename) => filename === `${sessionId}.jsonl`);
+  } else if (runtime === "codex") {
+    lookupMethod = "codex_jsonl";
+    for (const root of codexSessionRootCandidates(homeDir)) {
+      searchedPaths.push(root);
+      resolvedPath = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+      if (resolvedPath) break;
+    }
+  } else if (runtime === "grok") {
+    lookupMethod = "grok_session_jsonl";
+    const roots = [.../* @__PURE__ */ new Set([path14.join(homeDir, "sessions"), path14.join(homeDir, ".grok", "sessions")])];
+    for (const root of roots) {
+      searchedPaths.push(root);
+      resolvedPath = findGrokSessionTranscript(root, sessionId);
+      if (resolvedPath) break;
+    }
+  } else if (runtime === "kimi-sdk" || runtime === "kimi") {
+    lookupMethod = "kimi_sdk_index";
+    resolvedPath = findKimiSdkSessionDir(sessionId, opts?.agentId, homeDir);
+  } else if (runtime === "pi") {
+    lookupMethod = "pi_jsonl";
+    resolvedPath = findPiSessionFile2(sessionId, opts?.workingDirectory, homeDir);
+  }
+  if (!resolvedPath && fallbackDir) {
+    const fallback = writeRuntimeSessionHandoff(
+      runtime,
+      sessionId,
+      fallbackDir,
+      { launchId: opts?.launchId, processInstanceId: opts?.processInstanceId },
+      { lookupMethod, searchedPaths }
+    );
+    if (fallback) return { ...fallback, reason: `${fallback.reason}; attempted_lookup=${lookupMethod}` };
+  }
+  const ref = {
+    label: sessionId,
+    path: resolvedPath ?? sessionId,
+    runtime,
+    reachable: Boolean(resolvedPath)
+  };
+  if (!resolvedPath) {
+    ref.reason = `session file path not found; attempted_lookup=${lookupMethod}; searched=[${searchedPaths.join(", ")}]`;
+  }
+  return ref;
 }
 
 // src/drivers/index.ts
@@ -13531,6 +14664,7 @@ var driverFactories = {
   builtin: () => new BuiltInDriver(),
   claude: () => new ClaudeDriver(),
   codex: () => new CodexDriver(),
+  grok: () => new GrokDriver(),
   antigravity: () => new AntigravityDriver(),
   copilot: () => new CopilotDriver(),
   cursor: () => new CursorDriver(),
@@ -13611,22 +14745,22 @@ async function reapOrphanProcesses(pids, logger2, recordTrace) {
 
 // src/workspaces.ts
 import { access, mkdir, readdir, rm, stat, writeFile } from "fs/promises";
-import path13 from "path";
+import path15 from "path";
 async function initializeAgentWorkspace(workspacePath, initialMemoryMd, seedFiles) {
   await mkdir(workspacePath, { recursive: true });
-  const memoryMdPath = path13.join(workspacePath, "MEMORY.md");
+  const memoryMdPath = path15.join(workspacePath, "MEMORY.md");
   try {
     await access(memoryMdPath);
   } catch {
     await writeFile(memoryMdPath, initialMemoryMd);
   }
-  await mkdir(path13.join(workspacePath, "notes"), { recursive: true });
+  await mkdir(path15.join(workspacePath, "notes"), { recursive: true });
   for (const { relativePath, content } of seedFiles) {
-    const fullPath = path13.join(workspacePath, relativePath);
+    const fullPath = path15.join(workspacePath, relativePath);
     try {
       await access(fullPath);
     } catch {
-      await mkdir(path13.dirname(fullPath), { recursive: true });
+      await mkdir(path15.dirname(fullPath), { recursive: true });
       await writeFile(fullPath, content);
     }
   }
@@ -13638,7 +14772,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path13.join(dataDir, directoryName);
+  return path15.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -13687,7 +14821,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path13.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path15.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -13706,7 +14840,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path13.join(dataDir, entry.name);
+      const dirPath = path15.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -14869,6 +16003,8 @@ function runtimeDisplayName(runtimeId) {
       return "Claude Code";
     case "codex":
       return "Codex";
+    case "grok":
+      return "Grok Build";
     case "copilot":
       return "GitHub Copilot CLI";
     case "cursor":
@@ -15240,7 +16376,7 @@ function isWorkspaceNeverVisibleHiddenEntry(name) {
   return WORKSPACE_NEVER_VISIBLE_HIDDEN_NAMES.has(name) || name.startsWith(".slock-");
 }
 function workspacePathParts(relativePath) {
-  return relativePath.split(path14.sep).filter(Boolean);
+  return relativePath.split(path16.sep).filter(Boolean);
 }
 function isWorkspaceHiddenPath(relativePath) {
   return workspacePathParts(relativePath).some((part) => part.startsWith("."));
@@ -15305,7 +16441,7 @@ async function waitForRunnerCredentialRetry() {
 function probeSubprocessOsState(pid) {
   if (typeof pid !== "number") return "unknown";
   try {
-    const status = readFileSync6(`/proc/${pid}/status`, "utf8");
+    const status = readFileSync7(`/proc/${pid}/status`, "utf8");
     const match = status.match(/^State:\s+(\S)/m);
     if (match) {
       const code = match[1];
@@ -15356,40 +16492,21 @@ function getMessageShortId2(messageId2) {
 var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
 var SESSION_TRANSCRIPT_MAX_BYTES = 10 * 1024 * 1024;
 function runtimeTier(runtime) {
-  const tier1 = /* @__PURE__ */ new Set(["claude", "codex", "kimi-sdk", "kimi", "pi"]);
+  const tier1 = /* @__PURE__ */ new Set(["claude", "codex", "grok", "kimi-sdk", "kimi", "pi"]);
   if (tier1.has(runtime)) return "tier1";
   return "tier2_or_fallback";
 }
 function redactTranscript(text) {
   return text.replace(/sk_(?:agent|machine|computer)_[A-Za-z0-9_-]+/g, "sk_[redacted]").replace(/sap_[A-Za-z0-9_-]+/g, "sap_[redacted]").replace(/Bearer\s+[A-Za-z0-9_\-./+=]+/g, "Bearer [redacted]").replace(/["']?auth[_-]?token["']?\s*[:=]\s*["'][^"']+["']/gi, "[redacted]").replace(/https?:\/\/[^\s\"]+/g, "[url]");
 }
-function allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir) {
-  const roots = [workspaceDir];
-  switch (runtime) {
-    case "claude":
-      roots.push(path14.join(homeDir, ".claude"));
-      break;
-    case "codex":
-      roots.push(homeDir, path14.join(homeDir, ".codex"));
-      break;
-    case "kimi":
-    case "kimi-sdk":
-      roots.push(path14.join(homeDir, ".kimi"));
-      break;
-    case "pi":
-      roots.push(path14.join(homeDir, ".pi"), path14.join(homeDir, ".pi", "agent"));
-      break;
-  }
-  return roots;
-}
 async function isPathWithinAllowedRoots(filePath, roots) {
   const real = await realpath(filePath).catch(() => null);
   if (!real) return false;
   for (const root of roots) {
     const realRoot = await realpath(root).catch(() => null);
     if (!realRoot) continue;
-    const rel = path14.relative(realRoot, real);
-    if (!rel.startsWith("..") && !path14.isAbsolute(rel)) return true;
+    const rel = path16.relative(realRoot, real);
+    if (!rel.startsWith("..") && !path16.isAbsolute(rel)) return true;
   }
   return false;
 }
@@ -15421,186 +16538,6 @@ async function readAndRedact(filePath, maxBytes) {
     return null;
   }
 }
-function findSessionJsonl(root, predicate) {
-  let visited = 0;
-  const maxEntries = 1e4;
-  const maxDepth = 8;
-  const visit = (dir, depth) => {
-    if (depth < 0 || visited >= maxEntries) return null;
-    let entries;
-    try {
-      entries = readdirSync4(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
-    } catch {
-      return null;
-    }
-    for (const entry of entries) {
-      if (++visited > maxEntries) return null;
-      if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path14.join(dir, entry.name);
-    }
-    for (const entry of entries) {
-      if (++visited > maxEntries) return null;
-      if (!entry.isDirectory()) continue;
-      const found = visit(path14.join(dir, entry.name), depth - 1);
-      if (found) return found;
-    }
-    return null;
-  };
-  return visit(root, maxDepth);
-}
-function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
-  const indexPath = path14.join(homeDir, ".kimi", "session_index.jsonl");
-  try {
-    const index = readFileSync6(indexPath, "utf8");
-    for (const line of index.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const entry = JSON.parse(line);
-        if (entry.sessionId === sessionId && entry.sessionDir && existsSync8(entry.sessionDir)) {
-          return entry.sessionDir;
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  const sessionsRoot = path14.join(homeDir, ".kimi", "sessions");
-  try {
-    const prefix = agentId ? `wd_${agentId}_` : `wd_`;
-    for (const entry of readdirSync4(sessionsRoot, { withFileTypes: true })) {
-      if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
-      const candidate = path14.join(sessionsRoot, entry.name, `session_${sessionId}`);
-      if (existsSync8(candidate)) return candidate;
-    }
-  } catch {
-  }
-  return null;
-}
-function findPiSessionFile2(sessionId, workingDirectory, homeDir) {
-  if (workingDirectory) {
-    const piSessionsDir = path14.join(workingDirectory, ".pi-sessions");
-    try {
-      const files = readdirSync4(piSessionsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => ({ name: e.name, path: path14.join(piSessionsDir, e.name), stat: statSync(path14.join(piSessionsDir, e.name)) })).filter((f) => f.stat.isFile() && f.name.includes(sessionId)).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
-      if (files[0]) return files[0].path;
-    } catch {
-    }
-  }
-  const legacyRoots = [
-    path14.join(homeDir, ".pi", "agent"),
-    path14.join(homeDir, ".pi")
-  ];
-  for (const root of legacyRoots) {
-    const found = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
-    if (found) return found;
-  }
-  return null;
-}
-function safeSessionFilename(value) {
-  const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized || "unknown-session";
-}
-function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir, join, resolve) {
-  try {
-    const dir = path14.join(fallbackDir, ".slock", "runtime-sessions");
-    mkdirSync4(dir, { recursive: true });
-    const filePath = path14.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
-    const searchedPaths = resolve?.searchedPaths ?? [];
-    writeFileSync4(filePath, JSON.stringify({
-      type: "runtime_session_handoff",
-      runtime,
-      sessionId,
-      // Persisted L1<->L2 join keys (#460 V3): without these the
-      // session->launch mapping lives only in daemon memory and old L1
-      // transcripts can never re-join their launch after restart/adopt.
-      // ids-only, closed fields (no content payload).
-      launchId: join?.launchId ?? null,
-      processInstanceId: join?.processInstanceId ?? null,
-      // Negative-space (fruit#0 pt2): a resolve-miss is explicit evidence, not a
-      // silent "not found". Recording the lookup method + the directories checked
-      // makes "looked in the wrong place" distinguishable from "looked in the right
-      // place and it is genuinely absent". ids/paths only — no transcript content.
-      resolveStatus: "transcript_resolve_missing",
-      lookupMethod: resolve?.lookupMethod ?? "none",
-      searchedPaths,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      note: "The native runtime transcript file was not found on this machine; this daemon-created handoff records the runtime session identity + the directories checked for diagnostics."
-    }) + "\n", { mode: 384 });
-    return {
-      label: sessionId,
-      path: filePath,
-      runtime,
-      reachable: true,
-      reason: `native session file path not found; using daemon handoff file; searched=[${searchedPaths.join(", ")}]`
-    };
-  } catch {
-    return null;
-  }
-}
-function resolveRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
-  if (config.runtime === "codex") {
-    return resolveCodexHomeRootFromConfig(config, defaultHomeDir, workspacePath, process.env, opts);
-  }
-  return defaultHomeDir;
-}
-function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
-  if (config.runtime === "codex") {
-    const home = resolveCodexHomeRootFromConfig(config, defaultHomeDir, workspacePath, process.env, opts);
-    if (opts.agentId) {
-      mkdirSync4(home, { recursive: true });
-    }
-    return home;
-  }
-  return defaultHomeDir;
-}
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir, opts) {
-  let resolvedPath = null;
-  let lookupMethod = "none";
-  const searchedPaths = [];
-  if (runtime === "claude") {
-    lookupMethod = "claude_jsonl";
-    const claudeRoot = path14.join(homeDir, ".claude", "projects");
-    searchedPaths.push(claudeRoot);
-    resolvedPath = findSessionJsonl(claudeRoot, (filename) => filename === `${sessionId}.jsonl`);
-  } else if (runtime === "codex") {
-    lookupMethod = "codex_jsonl";
-    for (const root of codexSessionRootCandidates(homeDir)) {
-      searchedPaths.push(root);
-      resolvedPath = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
-      if (resolvedPath) break;
-    }
-  } else if (runtime === "kimi-sdk" || runtime === "kimi") {
-    lookupMethod = "kimi_sdk_index";
-    resolvedPath = findKimiSdkSessionDir(sessionId, opts?.agentId, homeDir);
-  } else if (runtime === "pi") {
-    lookupMethod = "pi_jsonl";
-    resolvedPath = findPiSessionFile2(sessionId, opts?.workingDirectory, homeDir);
-  }
-  if (!resolvedPath && fallbackDir) {
-    const fallback = writeRuntimeSessionHandoff(
-      runtime,
-      sessionId,
-      fallbackDir,
-      { launchId: opts?.launchId, processInstanceId: opts?.processInstanceId },
-      { lookupMethod, searchedPaths }
-    );
-    if (fallback) {
-      return {
-        ...fallback,
-        reason: `${fallback.reason}; attempted_lookup=${lookupMethod}`
-      };
-    }
-  }
-  const ref = {
-    label: sessionId,
-    path: resolvedPath ?? sessionId,
-    runtime,
-    reachable: Boolean(resolvedPath)
-  };
-  if (!resolvedPath) {
-    ref.reason = `session file path not found; attempted_lookup=${lookupMethod}; searched=[${searchedPaths.join(", ")}]`;
-  }
-  return ref;
-}
 function classifySpawnFailure(error) {
   const detail = error instanceof Error ? error.message : String(error);
   const lower = detail.toLowerCase();
@@ -16441,7 +17378,7 @@ function runtimeDiagnosticTitle(event) {
     case "deprecationNotice":
       return "Codex deprecation notice";
     default:
-      return "Codex warning";
+      return event.source === "grok_acp_notification" ? "Grok Build warning" : "Codex warning";
   }
 }
 function summarizeDiagnosticRange(range) {
@@ -16495,7 +17432,7 @@ function runtimeRecoveryTrajectoryEntry(event) {
   }
   return {
     kind: "system",
-    title: "Codex resume recovery",
+    title: event.source === "grok_resume_missing_session" ? "Grok resume recovery" : "Codex resume recovery",
     text: lines.join("\n")
   };
 }
@@ -16932,9 +17869,9 @@ var AgentProcessManager = class _AgentProcessManager {
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
-    this.slockHome = opts.slockHome ? path14.resolve(opts.slockHome) : resolveSlockHome();
+    this.slockHome = opts.slockHome ? path16.resolve(opts.slockHome) : resolveSlockHome();
     this.dataDir = opts.dataDir || resolveSlockHomePath("agents", this.slockHome);
-    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os6.homedir();
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os9.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
@@ -17303,8 +18240,8 @@ var AgentProcessManager = class _AgentProcessManager {
   broadcastMessageReceivedActivity(agentId) {
     this.broadcastActivity(agentId, "working", "Message received", [], void 0, "message_received");
   }
-  toolActivityDetailKind(toolName) {
-    switch (resolveToolSemantic(toolName) ?? toolName) {
+  toolActivityDetailKind(toolName2) {
+    switch (resolveToolSemantic(toolName2) ?? toolName2) {
       case "bash":
         return "running_command";
       case "check_messages":
@@ -17716,15 +18653,20 @@ var AgentProcessManager = class _AgentProcessManager {
       ...runtimeDiagnosticTraceAttrs(event)
     });
   }
-  /**
-   * APM 1.6 6a — surface a generic structured "working" signal from an
-   * internal_progress liveness tick during a long turn. Only transitions INTO
-   * the runtime-progress state once (idempotent while already in it) so the
-   * high-frequency Claude partial-message stream does not spam a rendered status
-   * line every tick; the activity heartbeat then keeps the signal live. Carries
-   * no raw content — a bounded "Working" detail only. Never marks a subagent.
-   */
-  maybeBroadcastRuntimeProgressActivity(agentId, ap) {
+  // Project bounded Working liveness without raw content or subagent state.
+  maybeBroadcastRuntimeProgressActivity(agentId, ap, event) {
+    if (this.isApmIdle(ap)) {
+      this.recordDaemonTrace("daemon.runtime.progress.activity.suppressed", {
+        agentId,
+        launchId: ap.launchId || void 0,
+        runtime: ap.config.runtime,
+        outcome: "apm_idle",
+        source: event.source,
+        itemType: event.itemType,
+        payloadBytes: event.payloadBytes
+      });
+      return;
+    }
     const alreadyLive = ap.lastActivityKind === "working" || ap.lastActivityKind === "thinking";
     if (alreadyLive) return;
     this.broadcastActivity(agentId, "working", "Working", [], void 0, "runtime_progress");
@@ -18247,7 +19189,7 @@ var AgentProcessManager = class _AgentProcessManager {
     let pendingStartRebind;
     const originalLaunchId = launchId || null;
     try {
-      const agentDataDir = path14.join(this.dataDir, agentId);
+      const agentDataDir = path16.join(this.dataDir, agentId);
       const initialRuntimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
       await initializeAgentWorkspace(
         agentDataDir,
@@ -19783,7 +20725,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     return true;
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path14.join(this.dataDir, agentId);
+    const agentDataDir = path16.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -19865,7 +20807,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId, observedRuntimeHomeDir, processInstanceId) {
-    const workspacePath = path14.join(this.dataDir, agentId);
+    const workspacePath = path16.join(this.dataDir, agentId);
     const runtimeHomeDir = observedRuntimeHomeDir || resolveRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspacePath, { agentId, slockHome: this.slockHome });
     return {
       agentId,
@@ -20201,7 +21143,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath, includeHidden = false) {
-    const agentDir = path14.join(this.dataDir, agentId);
+    const agentDir = path16.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -20209,11 +21151,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path14.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
+      const resolved = path16.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path16.sep) && resolved !== agentDir) {
         return [];
       }
-      const relativePath = path14.relative(agentDir, resolved);
+      const relativePath = path16.relative(agentDir, resolved);
       if (isWorkspaceNeverVisibleHiddenPath(relativePath)) {
         return [];
       }
@@ -20225,18 +21167,18 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     return this.listDirectoryChildren(targetDir, agentDir, includeHidden);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path14.join(this.dataDir, agentId);
-    const resolved = path14.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
+    const agentDir = path16.join(this.dataDir, agentId);
+    const resolved = path16.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path16.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
-    const relativePath = path14.relative(agentDir, resolved);
+    const relativePath = path16.relative(agentDir, resolved);
     if (isWorkspaceNeverVisibleHiddenPath(relativePath) || isWorkspaceSecretFilePath(relativePath)) {
       throw new Error("Preview is disabled for sensitive workspace files");
     }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const ext = path14.extname(resolved).toLowerCase();
+    const ext = path16.extname(resolved).toLowerCase();
     if (WORKSPACE_TEXT_EXTENSIONS.has(ext) || ext === "") {
       if (info.size > WORKSPACE_TEXT_FILE_MAX_BYTES) throw new Error("File too large");
       const content = await readFile(resolved, "utf-8");
@@ -20287,7 +21229,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       };
     }
     const runtime = config.runtime;
-    const workspaceDir = path14.join(this.dataDir, agentId);
+    const workspaceDir = path16.join(this.dataDir, agentId);
     const homeDir = agent?.runtime.currentRuntimeHomeDir || ensureRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspaceDir, { agentId, slockHome: this.slockHome });
     if (!actualSessionId) {
       return {
@@ -20328,7 +21270,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     let redacted = false;
     if (ref.reachable && ref.path) {
       try {
-        const resolved = path14.resolve(ref.path);
+        const resolved = path16.resolve(ref.path);
         const allowedRoots = allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir);
         if (!await isPathWithinAllowedRoots(resolved, allowedRoots)) {
           throw new Error("resolved session path is outside allowed runtime directories");
@@ -20339,7 +21281,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           throw new Error("symbolic links are not allowed");
         }
         if (info.isDirectory()) {
-          targetPath = path14.join(resolved, "state.json");
+          targetPath = path16.join(resolved, "state.json");
         }
         if (!await isPathWithinAllowedRoots(targetPath, allowedRoots)) {
           throw new Error("resolved session state path is outside allowed runtime directories");
@@ -20451,17 +21393,17 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     const idle = this.lifecycleRecords.getRestartSnapshot(agentId);
     const config = agent?.config ?? idle?.config ?? null;
     const runtime = runtimeHint || config?.runtime || "claude";
-    const workspaceDir = path14.join(this.dataDir, agentId);
-    const hostHome = os6.homedir();
+    const workspaceDir = path16.join(this.dataDir, agentId);
+    const hostHome = os9.homedir();
     const home = agent?.runtime.currentRuntimeHomeDir || (config ? ensureRuntimeHomeDir(config, hostHome, workspaceDir, { agentId, slockHome: this.slockHome }) : runtime === "codex" ? resolveCodexHomeRootFromEnv(process.env, { defaultHomeDir: hostHome, cwd: workspaceDir }) : hostHome);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalDirs = runtime === "codex" ? [
-      path14.join(home, "skills"),
-      path14.join(home, "skills", ".system"),
-      path14.join(home, ".agents", "skills"),
-      ...hasConfiguredCodexHome(config) ? [] : [path14.join(hostHome, ".agents", "skills")]
-    ] : paths.global.map((p) => path14.join(home, p));
-    const workspaceDirs = paths.workspace.map((p) => path14.join(workspaceDir, p));
+      path16.join(home, "skills"),
+      path16.join(home, "skills", ".system"),
+      path16.join(home, ".agents", "skills"),
+      ...hasConfiguredCodexHome(config) ? [] : [path16.join(hostHome, ".agents", "skills")]
+    ] : paths.global.map((p) => path16.join(home, p));
+    const workspaceDirs = paths.workspace.map((p) => path16.join(workspaceDir, p));
     const globalResults = await Promise.all(
       globalDirs.map((dir) => this.scanSkillsDir(dir))
     );
@@ -20495,7 +21437,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path14.join(dir, entry.name, "SKILL.md");
+        const skillMd = path16.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -20506,7 +21448,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path14.join(dir, entry.name), "utf-8");
+          const content = await readFile(path16.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -21722,7 +22664,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           itemType: event.itemType,
           payloadBytes: event.payloadBytes
         });
-        this.maybeBroadcastRuntimeProgressActivity(agentId, ap);
+        this.maybeBroadcastRuntimeProgressActivity(agentId, ap, event);
         return;
       }
       if (event.kind === "subagent_progress") {
@@ -22588,8 +23530,8 @@ ${RESPONSE_TARGET_HINT}`);
       const isHidden = entry.name.startsWith(".");
       if (entry.name === "node_modules") continue;
       if (isHidden && (!includeHidden || isWorkspaceNeverVisibleHiddenEntry(entry.name))) continue;
-      const fullPath = path14.join(dir, entry.name);
-      const relativePath = path14.relative(rootDir, fullPath);
+      const fullPath = path16.join(dir, entry.name);
+      const relativePath = path16.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -23071,9 +24013,9 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash as createHash4, randomUUID as randomUUID7 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
-import os7 from "os";
-import path15 from "path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import os10 from "os";
+import path17 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -23095,11 +24037,11 @@ function resolveDefaultMachineStateRoot() {
   return resolveSlockHomePath("machines");
 }
 function ownerPath(lockDir) {
-  return path15.join(lockDir, "owner.json");
+  return path17.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync7(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync8(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
@@ -23125,8 +24067,8 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? resolveDefaultMachineStateRoot();
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path15.join(rootDir, lockId);
-  const lockDir = path15.join(machineDir, "daemon.lock");
+  const machineDir = path17.join(rootDir, lockId);
+  const lockDir = path17.join(machineDir, "daemon.lock");
   const token = randomUUID7();
   mkdirSync5(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
@@ -23135,7 +24077,7 @@ function acquireDaemonMachineLock(options) {
       const owner = {
         pid: process.pid,
         token,
-        hostname: os7.hostname(),
+        hostname: os10.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
@@ -23187,7 +24129,7 @@ function acquireDaemonMachineLock(options) {
 
 // ../trace-client/src/localTraceSink.ts
 import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
-import path16 from "path";
+import path18 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
@@ -23232,7 +24174,7 @@ var LocalRotatingTraceSink = class {
   currentSize = 0;
   sequence = 0;
   constructor(options) {
-    this.traceDir = path16.join(options.machineDir, "traces");
+    this.traceDir = path18.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));
@@ -23262,7 +24204,7 @@ var LocalRotatingTraceSink = class {
     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 = path16.join(
+      this.currentFile = path18.join(
         this.traceDir,
         `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
@@ -23277,7 +24219,7 @@ var LocalRotatingTraceSink = class {
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
-      rmSync4(path16.join(this.traceDir, file), { force: true });
+      rmSync4(path18.join(this.traceDir, file), { force: true });
     }
   }
 };
@@ -23454,7 +24396,7 @@ function createTraceClient(options) {
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
 import { gzipSync as gzipSync2 } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 var TRACE_UPLOAD_SCOPE = "daemon-trace-bundle:create";
 var DEFAULT_UPLOAD_INTERVAL_MS = 5 * 60 * 1e3;
 var DEFAULT_MIN_FILE_AGE_MS = 60 * 1e3;
@@ -23537,7 +24479,7 @@ var DaemonTraceBundleUploader = class {
     }, nextMs);
   }
   async findUploadCandidates() {
-    const traceDir = path17.join(this.options.machineDir, "traces");
+    const traceDir = path19.join(this.options.machineDir, "traces");
     let names;
     try {
       names = await readdir3(traceDir);
@@ -23549,8 +24491,8 @@ var DaemonTraceBundleUploader = class {
     const currentFile = this.options.currentFileProvider?.();
     const candidates = [];
     for (const name of names.filter((entry) => entry.startsWith("daemon-trace-") && entry.endsWith(".jsonl")).sort()) {
-      const file = path17.join(traceDir, name);
-      if (currentFile && path17.resolve(file) === path17.resolve(currentFile)) continue;
+      const file = path19.join(traceDir, name);
+      if (currentFile && path19.resolve(file) === path19.resolve(currentFile)) continue;
       if (await this.isUploaded(file)) continue;
       try {
         const info = await stat3(file);
@@ -23628,8 +24570,8 @@ var DaemonTraceBundleUploader = class {
     }
   }
   uploadStatePath(file) {
-    const stateDir = path17.join(this.options.machineDir, "trace-uploads");
-    return path17.join(stateDir, `${path17.basename(file)}.uploaded.json`);
+    const stateDir = path19.join(this.options.machineDir, "trace-uploads");
+    return path19.join(stateDir, `${path19.basename(file)}.uploaded.json`);
   }
   async isUploaded(file) {
     try {
@@ -23641,9 +24583,9 @@ var DaemonTraceBundleUploader = class {
   }
   async markUploaded(file, metadata) {
     const stateFile = this.uploadStatePath(file);
-    await mkdir2(path17.dirname(stateFile), { recursive: true, mode: 448 });
+    await mkdir2(path19.dirname(stateFile), { recursive: true, mode: 448 });
     await writeFile2(stateFile, `${JSON.stringify({
-      file: path17.basename(file),
+      file: path19.basename(file),
       uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...metadata
     }, null, 2)}
@@ -23661,15 +24603,15 @@ function readPositiveIntegerEnv2(name, fallback) {
 }
 
 // src/computerMigrationGuard.ts
-import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync10 } from "fs";
+import path20 from "path";
 
 // src/legacySupervisor.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
+import { readFileSync as readFileSync9 } from "fs";
 function execFileText(file, args) {
   try {
-    return execFileSync4(file, args, {
+    return execFileSync5(file, args, {
       encoding: "utf8",
       timeout: 1e3,
       maxBuffer: 256 * 1024,
@@ -23681,7 +24623,7 @@ function execFileText(file, args) {
 }
 function readFileText(file) {
   try {
-    return readFileSync8(file, "utf8");
+    return readFileSync9(file, "utf8");
   } catch {
     return void 0;
   }
@@ -23849,7 +24791,7 @@ function daemonApiKeyFingerprint(apiKey) {
   return getDaemonMachineLockId(apiKey).slice("machine-".length);
 }
 function findAdoptedComputerForLegacyFingerprint(slockHome, legacyApiKeyFingerprint) {
-  const serversDir = path18.join(slockHome, "computer", "servers");
+  const serversDir = path20.join(slockHome, "computer", "servers");
   if (!existsSync9(serversDir)) return null;
   let serverDirs;
   try {
@@ -23858,10 +24800,10 @@ function findAdoptedComputerForLegacyFingerprint(slockHome, legacyApiKeyFingerpr
     return null;
   }
   for (const serverId of serverDirs) {
-    const attachmentPath = path18.join(serversDir, serverId, "runner.state.json");
+    const attachmentPath = path20.join(serversDir, serverId, "runner.state.json");
     let raw;
     try {
-      raw = readFileSync9(attachmentPath, "utf8");
+      raw = readFileSync10(attachmentPath, "utf8");
     } catch {
       continue;
     }
@@ -24409,7 +25351,7 @@ function onceDrain(res) {
 import { createHash as createHash9 } from "crypto";
 import { createReadStream as createReadStream2, createWriteStream } from "fs";
 import { lstat as lstat3, mkdir as mkdir3, readlink as readlink2, rm as rm3, symlink } from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 import { Transform } from "stream";
 import { pipeline } from "stream/promises";
 import { createGunzip, createGzip } from "zlib";
@@ -24419,7 +25361,7 @@ import { extract, pack } from "tar-stream";
 import { createHash as createHash8 } from "crypto";
 import { createReadStream } from "fs";
 import { lstat as lstat2, readdir as readdir4, readFile as readFile3, readlink } from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 var AGENT_MIGRATION_BUNDLE_SCHEMA_VERSION = "agent-bundle/v1";
 var REGENERABLE_DIRECTORY_NAMES = [
   ".cache",
@@ -24443,8 +25385,8 @@ var SECRET_FILE_NAMES = /* @__PURE__ */ new Set([
 ]);
 var ENV_KEY_PATTERN = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
 async function buildAgentMigrationExportManifest(input) {
-  const slockHome = path19.resolve(input.slockHome);
-  const workspace = path19.resolve(input.workspacePath ?? path19.join(slockHome, "agents", input.agentId));
+  const slockHome = path21.resolve(input.slockHome);
+  const workspace = path21.resolve(input.workspacePath ?? path21.join(slockHome, "agents", input.agentId));
   const proposedIncludes = normalizeProposalPaths(input.cooperativeManifest?.include, workspace, "include");
   const proposedRegenerableExcludes = normalizeProposalPaths(input.cooperativeManifest?.exclude_regenerable, workspace, "exclude_regenerable");
   const cleanedProposal = normalizeProposalPaths(input.cooperativeManifest?.cleaned, workspace, "cleaned");
@@ -24505,7 +25447,7 @@ async function buildAgentMigrationExportManifest(input) {
   };
 }
 async function walkWorkspace(root, relativeDir, proposedRegenerableExcludes, state, opts) {
-  const absoluteDir = path19.join(root, relativeDir);
+  const absoluteDir = path21.join(root, relativeDir);
   let entries;
   try {
     entries = await readdir4(absoluteDir, { withFileTypes: true });
@@ -24519,7 +25461,7 @@ async function walkWorkspace(root, relativeDir, proposedRegenerableExcludes, sta
   }
   entries.sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const relativePath = toPosixPath(path19.join(relativeDir, entry.name));
+    const relativePath = toPosixPath(path21.join(relativeDir, entry.name));
     if (entry.isDirectory()) {
       if (!opts.forceIncludeRegenerable && isRegenerablePath(relativePath)) {
         if (state.explicitIncludePaths.has(relativePath)) {
@@ -24546,7 +25488,7 @@ async function walkWorkspace(root, relativeDir, proposedRegenerableExcludes, sta
 async function includeWorkspacePath(workspaceRelativePath, state, opts) {
   const normalizedRelativePath = normalizeRelativePath(workspaceRelativePath);
   if (state.seenWorkspacePaths.has(normalizedRelativePath)) return;
-  const sourcePath = path19.join(state.workspace, normalizedRelativePath);
+  const sourcePath = path21.join(state.workspace, normalizedRelativePath);
   let stat5;
   try {
     stat5 = await lstat2(sourcePath);
@@ -24563,7 +25505,7 @@ async function includeWorkspacePath(workspaceRelativePath, state, opts) {
       state.excludedRegenerable.push({
         path: normalizedRelativePath,
         reason: "cooperative_exclude_regenerable",
-        regenerableHint: `${path19.basename(normalizedRelativePath)} is treated as rebuildable/installable state and is not bundled by default`
+        regenerableHint: `${path21.basename(normalizedRelativePath)} is treated as rebuildable/installable state and is not bundled by default`
       });
       return;
     }
@@ -24610,8 +25552,8 @@ async function includeWorkspacePath(workspaceRelativePath, state, opts) {
 async function buildCrossTreeRefs(refs) {
   const result = [];
   for (const ref of refs) {
-    const sourcePath = path19.resolve(ref.path);
-    const bundlePath = `runtime/${safeBundleSegment(ref.runtime)}/${safeBundleSegment(ref.label)}/${safeBundleSegment(path19.basename(sourcePath) || "session")}`;
+    const sourcePath = path21.resolve(ref.path);
+    const bundlePath = `runtime/${safeBundleSegment(ref.runtime)}/${safeBundleSegment(ref.label)}/${safeBundleSegment(path21.basename(sourcePath) || "session")}`;
     const entry = {
       runtime: ref.runtime,
       label: ref.label,
@@ -24644,7 +25586,7 @@ async function sha256File(filePath) {
   return hash.digest("hex");
 }
 async function detectSecretShapes(sourcePath, relativePath) {
-  const basename = path19.basename(relativePath);
+  const basename = path21.basename(relativePath);
   const lowerBasename = basename.toLowerCase();
   const shapes = /* @__PURE__ */ new Set();
   if (SECRET_FILE_NAMES.has(lowerBasename) || lowerBasename.startsWith(".env.")) {
@@ -24677,9 +25619,9 @@ function normalizeProposalPaths(paths, workspace, source) {
   for (const value of paths) {
     const trimmed = value.trim();
     if (!trimmed) continue;
-    if (path19.isAbsolute(trimmed)) {
-      const relative = path19.relative(workspace, trimmed);
-      if (relative.startsWith("..") || path19.isAbsolute(relative)) {
+    if (path21.isAbsolute(trimmed)) {
+      const relative = path21.relative(workspace, trimmed);
+      if (relative.startsWith("..") || path21.isAbsolute(relative)) {
         refusals.push({
           path: trimmed,
           reason: "outside_workspace",
@@ -24711,8 +25653,8 @@ function normalizeProposalPaths(paths, workspace, source) {
   return { paths: [...new Set(result)], refusals };
 }
 function normalizeRelativePath(value) {
-  const normalized = path19.normalize(value).replace(/^[\\/]+/, "");
-  if (!normalized || normalized === "." || normalized.startsWith("..") || path19.isAbsolute(normalized)) {
+  const normalized = path21.normalize(value).replace(/^[\\/]+/, "");
+  if (!normalized || normalized === "." || normalized.startsWith("..") || path21.isAbsolute(normalized)) {
     throw new Error(`unsafe migration export path: ${value}`);
   }
   return toPosixPath(normalized);
@@ -24731,7 +25673,7 @@ function safeBundleSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
 }
 function toPosixPath(value) {
-  return value.split(path19.sep).join("/");
+  return value.split(path21.sep).join("/");
 }
 function sortBundleEntries(entries) {
   return [...entries].sort((a, b) => a.bundlePath.localeCompare(b.bundlePath));
@@ -24760,7 +25702,7 @@ var AgentMigrationObjectStoreBundleTooLargeError = class extends Error {
 };
 async function buildAgentMigrationObjectStoreBundle(input) {
   assertPositiveMaxBytes(input.maxBytes);
-  const workspacePath = path20.resolve(input.workspacePath);
+  const workspacePath = path22.resolve(input.workspacePath);
   const manifest = await buildAgentMigrationExportManifest({
     agentId: input.agentId,
     slockHome: input.slockHome,
@@ -24793,8 +25735,8 @@ async function buildAgentMigrationObjectStoreBundle(input) {
 }
 async function stageAgentMigrationObjectStoreBundle(input) {
   assertPositiveMaxBytes(input.maxBytes);
-  const stagingWorkspacePath = path20.join(
-    path20.resolve(input.slockHome),
+  const stagingWorkspacePath = path22.join(
+    path22.resolve(input.slockHome),
     "migrations",
     sanitizePathSegment(input.sessionId),
     "workspace"
@@ -24866,7 +25808,7 @@ async function writeArchive(tarPack, manifestBuffer, manifest, workspacePath) {
       throw new Error("MIGRATION_OBJECT_STORE_UNSUPPORTED_ENTRY");
     }
     const relativePath = normalizeWorkspaceRelativePath(entry.workspaceRelativePath);
-    const sourcePath = path20.resolve(entry.sourcePath);
+    const sourcePath = path22.resolve(entry.sourcePath);
     const archivePath = `${ARCHIVE_WORKSPACE_PREFIX}${relativePath}`;
     if (entry.kind === "symlink") {
       await writeBufferedEntry(tarPack, {
@@ -24916,8 +25858,8 @@ async function handleArchiveEntry(input) {
   const expected = input.getExpectedEntries().get(relativePath);
   if (!expected) throw new Error(`MIGRATION_OBJECT_STORE_ARCHIVE_ENTRY_UNEXPECTED:${relativePath}`);
   input.extractedEntries.add(relativePath);
-  const targetPath = path20.join(input.stagingWorkspacePath, relativePath);
-  await mkdir3(path20.dirname(targetPath), { recursive: true });
+  const targetPath = path22.join(input.stagingWorkspacePath, relativePath);
+  await mkdir3(path22.dirname(targetPath), { recursive: true });
   if (expected.kind === "symlink") {
     if (input.header.type !== "symlink" || input.header.linkname !== expected.linkTarget) {
       throw new Error(`MIGRATION_OBJECT_STORE_LINK_TARGET_MISMATCH:${relativePath}`);
@@ -25034,8 +25976,8 @@ function encodeAccountingPath(value) {
   return encoded;
 }
 function normalizeWorkspaceRelativePath(relativePath) {
-  const normalized = path20.posix.normalize(relativePath.replaceAll("\\", "/"));
-  if (normalized === "." || normalized.startsWith("../") || normalized === ".." || path20.isAbsolute(normalized)) {
+  const normalized = path22.posix.normalize(relativePath.replaceAll("\\", "/"));
+  if (normalized === "." || normalized.startsWith("../") || normalized === ".." || path22.isAbsolute(normalized)) {
     throw new Error("MIGRATION_OBJECT_STORE_UNSAFE_PATH");
   }
   return normalized;
@@ -25096,15 +26038,15 @@ function sanitizePathSegment(value) {
 import { createHash as createHash10 } from "crypto";
 import { createReadStream as createReadStream3 } from "fs";
 import { access as access2, cp, lstat as lstat4, mkdir as mkdir4, readlink as readlink3, rename, writeFile as writeFile3 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 async function buildAgentMigrationAdoptPlan(input) {
-  const slockHome = path21.resolve(input.slockHome);
+  const slockHome = path23.resolve(input.slockHome);
   let manifest;
   if (input.sourceKind === "orphan_directory" && !input.manifest) {
     manifest = await buildAgentMigrationExportManifest({
       agentId: input.agentId,
       slockHome,
-      workspacePath: path21.resolve(input.orphanWorkspacePath),
+      workspacePath: path23.resolve(input.orphanWorkspacePath),
       mode: "forensic",
       now: input.now
     });
@@ -25117,11 +26059,11 @@ async function buildAgentMigrationAdoptPlan(input) {
     manifest,
     expectedAgentId: input.sourceKind === "orphan_directory" ? input.agentId : manifest.agentId
   });
-  const sourceWorkspacePath = path21.resolve(
+  const sourceWorkspacePath = path23.resolve(
     input.sourceKind === "staged_bundle" ? input.stagingWorkspacePath : input.orphanWorkspacePath
   );
-  const finalWorkspacePath = path21.resolve(input.finalWorkspacePath ?? path21.join(slockHome, "agents", manifest.agentId));
-  const reportPath = path21.resolve(input.reportPath ?? path21.join(
+  const finalWorkspacePath = path23.resolve(input.finalWorkspacePath ?? path23.join(slockHome, "agents", manifest.agentId));
+  const reportPath = path23.resolve(input.reportPath ?? path23.join(
     slockHome,
     "migrations",
     sanitizePathSegment2(input.generation.grantKey),
@@ -25246,7 +26188,7 @@ async function verifyManifestFileEntry(sourceWorkspacePath, entry) {
     throw new Error("MIGRATION_MANIFEST_ENTRY_NOT_WORKSPACE");
   }
   const relative = normalizeWorkspaceRelativePath2(entry.workspaceRelativePath);
-  const entryPath = path21.join(sourceWorkspacePath, relative);
+  const entryPath = path23.join(sourceWorkspacePath, relative);
   const info = await lstat4(entryPath).catch(() => null);
   if (!info) throw new Error("MIGRATION_MANIFEST_FILE_MISSING");
   if (entry.kind === "symlink") {
@@ -25265,14 +26207,14 @@ async function verifyManifestFileEntry(sourceWorkspacePath, entry) {
   }
 }
 function normalizeWorkspaceRelativePath2(relativePath) {
-  const normalized = path21.posix.normalize(relativePath.replaceAll("\\", "/"));
-  if (normalized === "." || normalized.startsWith("../") || normalized === ".." || path21.isAbsolute(normalized)) {
+  const normalized = path23.posix.normalize(relativePath.replaceAll("\\", "/"));
+  if (normalized === "." || normalized.startsWith("../") || normalized === ".." || path23.isAbsolute(normalized)) {
     throw new Error("MIGRATION_MANIFEST_UNSAFE_PATH");
   }
   return normalized;
 }
 async function assertFinalWorkspaceAvailable(sourceWorkspacePath, finalWorkspacePath) {
-  if (path21.resolve(sourceWorkspacePath) === path21.resolve(finalWorkspacePath)) return;
+  if (path23.resolve(sourceWorkspacePath) === path23.resolve(finalWorkspacePath)) return;
   try {
     await access2(finalWorkspacePath);
     throw new Error("MIGRATION_WORKSPACE_ALREADY_EXISTS");
@@ -25281,9 +26223,9 @@ async function assertFinalWorkspaceAvailable(sourceWorkspacePath, finalWorkspace
   }
 }
 async function placeWorkspace(sourceWorkspacePath, finalWorkspacePath) {
-  if (path21.resolve(sourceWorkspacePath) === path21.resolve(finalWorkspacePath)) return;
+  if (path23.resolve(sourceWorkspacePath) === path23.resolve(finalWorkspacePath)) return;
   const stagingPath = `${finalWorkspacePath}.migration-${process.pid}-${Date.now()}`;
-  await mkdir4(path21.dirname(finalWorkspacePath), { recursive: true });
+  await mkdir4(path23.dirname(finalWorkspacePath), { recursive: true });
   await cp(sourceWorkspacePath, stagingPath, {
     recursive: true,
     dereference: false,
@@ -25296,7 +26238,7 @@ async function placeWorkspace(sourceWorkspacePath, finalWorkspacePath) {
 async function writeArrivalReport(reportPath, report) {
   const payload = `${canonicalJson3(report)}
 `;
-  await mkdir4(path21.dirname(reportPath), { recursive: true });
+  await mkdir4(path23.dirname(reportPath), { recursive: true });
   await writeFile3(reportPath, payload, { mode: 384 });
   return sha256Buffer3(Buffer.from(payload, "utf8"));
 }
@@ -25327,10 +26269,10 @@ function sanitizePathSegment2(value) {
 }
 
 // src/secretFile.ts
-import { chmodSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
-import path22 from "path";
+import { chmodSync, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
+import path24 from "path";
 function readSecretFileSync(filePath) {
-  return readFileSync10(filePath, "utf8").trim();
+  return readFileSync11(filePath, "utf8").trim();
 }
 
 // src/core.ts
@@ -25429,6 +26371,9 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
   "daemon.runtime_profile.report.sent": {
     spanAttrs: ["agentId", "launchId", "runtime", "report_source", "model_present", "session_ref_present", "workspace_ref_present"]
   },
+  "daemon.runtime.progress.activity.suppressed": {
+    spanAttrs: ["agentId", "launchId", "runtime", "outcome", "source", "itemType", "payloadBytes"]
+  },
   "daemon.runtime_models.detect": {
     spanAttrs: ["runtime", "requestId"],
     eventAttrs: {
@@ -25628,13 +26573,13 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path23.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path23.resolve(thisDir, "cli", "index.js");
+  const thisDir = path25.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path25.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path23.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path25.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -25648,7 +26593,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-RESRARWP.js");
+  await import("./dist-HDPAZ76N.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -25876,7 +26821,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path23.join(path23.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path25.join(path25.dirname(this.options.dataDir), "machines");
     return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
@@ -25904,7 +26849,7 @@ var DaemonCore = class {
       sinks: [this.localTraceSink]
     }));
     this.agentManager.setTracer(this.tracer);
-    this.agentManager.setCliTransportTraceDir(path23.join(machineDir, "traces"));
+    this.agentManager.setCliTransportTraceDir(path25.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -26228,11 +27173,11 @@ var DaemonCore = class {
     const built = await buildAgentMigrationObjectStoreBundle({
       agentId: lease.agentId,
       slockHome: this.slockHome,
-      workspacePath: path23.join(this.agentsDataDir, lease.agentId),
+      workspacePath: path25.join(this.agentsDataDir, lease.agentId),
       maxBytes: lease.maxBytes
     });
-    const spoolDirectory = await mkdtemp(path23.join(os8.tmpdir(), "raft-agent-migration-upload-"));
-    const spoolPath = path23.join(spoolDirectory, "bundle.tar.gz");
+    const spoolDirectory = await mkdtemp(path25.join(os11.tmpdir(), "raft-agent-migration-upload-"));
+    const spoolPath = path25.join(spoolDirectory, "bundle.tar.gz");
     let archiveBytes = 0;
     let uploadStatus = 0;
     try {
@@ -26295,7 +27240,7 @@ var DaemonCore = class {
       sourceKind: "staged_bundle",
       slockHome: this.slockHome,
       stagingWorkspacePath: staged.stagingWorkspacePath,
-      finalWorkspacePath: path23.join(this.agentsDataDir, lease.agentId),
+      finalWorkspacePath: path25.join(this.agentsDataDir, lease.agentId),
       manifest: staged.manifest,
       manifestSha256: staged.manifestSha256,
       generation: {
@@ -27049,8 +27994,8 @@ var DaemonCore = class {
       ],
       runtimes,
       runningAgents: runningAgentIds,
-      hostname: this.options.hostname ?? os8.hostname(),
-      os: this.options.osDescription ?? `${os8.platform()} ${os8.arch()}`,
+      hostname: this.options.hostname ?? os11.hostname(),
+      os: this.options.osDescription ?? `${os11.platform()} ${os11.arch()}`,
       daemonVersion: this.daemonVersion,
       ...this.computerVersion ? { computerVersion: this.computerVersion } : {},
       migrationTransport: this.getMigrationTransportReady(),