@alook/daemon 0.1.25 → 0.1.26

package/dist/cli/index.js

@@ -17536,7 +17536,7 @@ var REASONING_EFFORT_RE = /^[A-Za-z0-9._-]+$/;
 var COMMUNITY_REASONING_EFFORT_MAX = 32;
 var COMMUNITY_REASONING_DESCRIPTION_MAX = 256;
 var COMMUNITY_REASONING_OPTIONS_MAX = 16;
-var COMMUNITY_REASONING_MODELS_MAX = 64;
+var COMMUNITY_REASONING_MODELS_MAX = 512;
 var ReasoningEffortSchema = exports_external.string().min(1).max(COMMUNITY_REASONING_EFFORT_MAX).regex(REASONING_EFFORT_RE, "invalid reasoning effort charset");
 var RuntimeReasoningOptionSchema = exports_external.object({
   value: ReasoningEffortSchema,
@@ -17544,6 +17544,7 @@ var RuntimeReasoningOptionSchema = exports_external.object({
 });
 var RuntimeReasoningModelSchema = exports_external.object({
   id: exports_external.string().min(1).max(100),
+  displayName: exports_external.string().min(1).max(COMMUNITY_REASONING_DESCRIPTION_MAX).optional().catch(undefined),
   supportedReasoningEfforts: exports_external.array(exports_external.unknown()).max(COMMUNITY_REASONING_OPTIONS_MAX).transform((options) => {
     const seen = new Set;
     return options.flatMap((candidate) => {
@@ -20338,8 +20339,8 @@ function resolveLaunchFieldsOrDefault(input) {
   const envVars = Object.fromEntries(Object.entries(normalized.environment ?? {}).filter(([key]) => !controlled.has(key)));
   const providerEnv = {};
   const model = normalized.model.kind === "default" ? undefined : normalized.model.name;
-  if (normalized.model.kind === "custom" && normalized.provider?.kind === "custom_endpoint") {
-    providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = normalized.model.name;
+  if (model && normalized.provider?.kind === "custom_endpoint") {
+    providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = model;
   }
   if (normalized.provider?.kind === "custom_endpoint") {
     providerEnv.ANTHROPIC_BASE_URL = normalized.provider.apiUrl;
@@ -20674,6 +20675,7 @@ import { execFileSync as execFileSync2 } from "child_process";
 import * as fs5 from "fs";
 import * as path5 from "path";
 var PROBE_TIMEOUT_MS = 5000;
+var PROBE_OUTPUT_MAX_BYTES = 1024 * 1024;
 function resolveCommandOnPath(command, deps = {}) {
   if (deps.which)
     return deps.which(command);
@@ -20724,6 +20726,23 @@ function probeCommandVersion(command, args = [], deps = {}, platform = process.p
     return { ok: false, error: String(code) };
   }
 }
+function probeCommandOutput(command, args, platform = process.platform) {
+  try {
+    const output = execFileSync2(command, args, {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      maxBuffer: PROBE_OUTPUT_MAX_BYTES,
+      shell: needsWindowsShimShell(command, platform),
+      stdio: ["pipe", "pipe", "ignore"],
+      input: "",
+      env: { ...process.env, CI: "1" }
+    });
+    return { ok: true, output };
+  } catch (err) {
+    const code = err?.code ?? "command_probe_failed";
+    return { ok: false, error: String(code) };
+  }
+}
 function resolveHomePath(relativePath, deps = {}) {
   return path5.join(deps.homeDir || process.env.HOME || ".", relativePath);
 }
@@ -20830,6 +20849,14 @@ class ClaudeTurnProtocol {
 }
 
 // agent-driver/dist/adapters/claude/index.js
+var CLAUDE_MODEL_CATALOG = {
+  updateMode: "unsupported",
+  models: ["opus", "sonnet", "haiku"].map((id) => ({
+    id,
+    supportedReasoningEfforts: []
+  }))
+};
+
 class ClaudeDriver {
   id = "claude";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
@@ -20846,10 +20873,11 @@ class ClaudeDriver {
   }
   probe(command) {
     const explicit = command?.trim();
-    if (!explicit)
-      return probeClaude();
-    const result = probeCommandVersion(explicit);
-    return result.ok ? { status: "healthy", version: result.version } : { status: "unhealthy", lastError: result.error };
+    const base = explicit ? (() => {
+      const result = probeCommandVersion(explicit);
+      return result.ok ? { status: "healthy", version: result.version } : { status: "unhealthy", lastError: result.error };
+    })() : probeClaude();
+    return base.status === "healthy" ? { ...base, reasoning: CLAUDE_MODEL_CATALOG } : base;
   }
   async openLane(ctx, options) {
     return createProcessLane(this, ctx, { onRawStdoutLine: options?.onRawStdoutLine });
@@ -21416,10 +21444,59 @@ function stableErrorCode(value, fallback) {
   return /^[A-Za-z0-9_.-]{1,100}$/.test(code) ? code : fallback;
 }
 
+// agent-driver/dist/internal/modelCatalog.js
+var RUNTIME_MODEL_CATALOG_MAX = 512;
+var RUNTIME_MODEL_ID_MAX = 100;
+function normalizeRuntimeModelId(value) {
+  if (typeof value !== "string")
+    return;
+  const id = value.trim();
+  if (!id || id.length > RUNTIME_MODEL_ID_MAX || /\s/.test(id))
+    return;
+  return id;
+}
+function catalogFromIds(ids) {
+  const seen = new Set;
+  const models = [];
+  for (const rawId of ids) {
+    const id = normalizeRuntimeModelId(rawId);
+    if (!id || seen.has(id))
+      continue;
+    if (models.length >= RUNTIME_MODEL_CATALOG_MAX)
+      return;
+    seen.add(id);
+    models.push({ id, supportedReasoningEfforts: [] });
+  }
+  if (models.length === 0)
+    return;
+  return { updateMode: "unsupported", models };
+}
+function parseOpenCodeModelCatalog(output) {
+  const ids = output.split(/\r?\n/).flatMap((line) => {
+    const id = normalizeRuntimeModelId(line);
+    return id && /^[^/]+\/.+$/.test(id) ? [id] : [];
+  });
+  return catalogFromIds(ids);
+}
+function parsePiModelCatalog(values) {
+  if (!Array.isArray(values))
+    return;
+  const ids = values.flatMap((value) => {
+    if (!value || typeof value !== "object")
+      return [];
+    const model = value;
+    const provider = normalizeRuntimeModelId(model.provider);
+    const id = normalizeRuntimeModelId(model.id);
+    return provider && id && !provider.includes("/") ? [`${provider}/${id}`] : [];
+  });
+  return catalogFromIds(ids);
+}
+
 // agent-driver/dist/adapters/codex/index.js
 var SETTINGS_UPDATE_TIMEOUT_MS = 5000;
 var MODEL_LIST_TIMEOUT_MS = 5000;
-var MODEL_LIST_MAX = 64;
+var MODEL_LIST_OUTPUT_MAX_BYTES = 1024 * 1024;
+var MODEL_LIST_MAX = RUNTIME_MODEL_CATALOG_MAX;
 var MODEL_EFFORT_MAX = 16;
 function isCodexMissingRolloutError(message2) {
   return /\bno\s+rollout\s+found\b/i.test(message2) || /\bmissing\s+rollout\b/i.test(message2) || /\brollout\b.*\b(not found|missing)\b/i.test(message2) || /\b(not found|missing)\b.*\brollout\b/i.test(message2);
@@ -21495,11 +21572,13 @@ class CodexDriver {
     return new Promise((resolve2) => {
       let settled = false;
       let buffer = "";
+      let outputBytes = 0;
       let nextId = 0;
       let initializeId = 0;
       let listId = 0;
       const models = [];
       const seenModels = new Set;
+      let overflow = false;
       let defaultModelId;
       const finish = (catalog) => {
         if (settled)
@@ -21517,12 +21596,16 @@ class CodexDriver {
 `);
       };
       const consumeModel = (value) => {
-        if (!value || typeof value !== "object" || models.length >= MODEL_LIST_MAX)
+        if (!value || typeof value !== "object")
           return;
         const model = value;
-        const id = typeof model.id === "string" ? model.id.trim() : "";
-        if (!id || id.length > 100 || seenModels.has(id))
+        const id = normalizeRuntimeModelId(model.id);
+        if (!id || seenModels.has(id))
           return;
+        if (models.length >= MODEL_LIST_MAX) {
+          overflow = true;
+          return;
+        }
         const rawOptions = Array.isArray(model.supportedReasoningEfforts) ? model.supportedReasoningEfforts : [];
         const seenEfforts = new Set;
         const supportedReasoningEfforts = rawOptions.flatMap((raw) => {
@@ -21566,9 +21649,15 @@ class CodexDriver {
         const result = message2.result;
         for (const model of Array.isArray(result.data) ? result.data : [])
           consumeModel(model);
+        if (overflow)
+          return finish();
         const cursor = typeof result.nextCursor === "string" ? result.nextCursor : undefined;
-        if (cursor && models.length < MODEL_LIST_MAX)
+        if (cursor && models.length >= MODEL_LIST_MAX)
+          return finish();
+        if (cursor)
           return requestModelPage(cursor);
+        if (models.length === 0)
+          return finish();
         finish({
           updateMode: "live_next_turn",
           ...defaultModelId ? { defaultModelId } : {},
@@ -21578,7 +21667,11 @@ class CodexDriver {
       const timer = setTimeout(() => finish(), MODEL_LIST_TIMEOUT_MS);
       timer.unref?.();
       proc.stdout?.on("data", (chunk2) => {
-        buffer += chunk2.toString();
+        const text2 = chunk2.toString();
+        outputBytes += Buffer.byteLength(text2);
+        if (outputBytes > MODEL_LIST_OUTPUT_MAX_BYTES)
+          return finish();
+        buffer += text2;
         const lines = buffer.split(`
 `);
         buffer = lines.pop() ?? "";
@@ -21781,9 +21874,189 @@ class CodexDriver {
 
 // agent-driver/dist/adapters/cursor/acp-lane.js
 import { EventEmitter as EventEmitter2 } from "node:events";
+
+// agent-driver/dist/adapters/cursor/catalog-probe.js
 var ACP_PROTOCOL_VERSION = 1;
-var HANDSHAKE_TIMEOUT_MS = 15000;
 var AUTH_METHOD_ID = "cursor_login";
+var CATALOG_PROBE_TIMEOUT_MS = 15000;
+var CATALOG_PROBE_OUTPUT_MAX_BYTES = 1024 * 1024;
+var MODEL_DISPLAY_NAME_MAX = 256;
+var MODEL_OPTION_NESTING_MAX = 16;
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeDisplayName(value) {
+  if (typeof value !== "string")
+    return;
+  const displayName = value.trim();
+  return displayName && displayName.length <= MODEL_DISPLAY_NAME_MAX ? displayName : undefined;
+}
+function flattenCursorAcpSelectOptions(value, depth = 0) {
+  if (!Array.isArray(value) || depth > MODEL_OPTION_NESTING_MAX)
+    return [];
+  const options = [];
+  for (const item of value) {
+    if (Array.isArray(item)) {
+      options.push(...flattenCursorAcpSelectOptions(item, depth + 1));
+      continue;
+    }
+    const candidate = record2(item);
+    if (!candidate)
+      continue;
+    const exactValue = normalizeRuntimeModelId(candidate.value);
+    if (exactValue) {
+      const name = normalizeDisplayName(candidate.name);
+      options.push({ value: exactValue, ...name ? { name } : {} });
+    }
+    if (Array.isArray(candidate.options)) {
+      options.push(...flattenCursorAcpSelectOptions(candidate.options, depth + 1));
+    }
+  }
+  return options;
+}
+function parseCursorAcpModelCatalog(session2) {
+  const payload = record2(session2);
+  const configOptions = Array.isArray(payload?.configOptions) ? payload.configOptions : [];
+  const modelConfig = configOptions.map(record2).find((option) => option?.id === "model") ?? null;
+  if (!modelConfig)
+    return;
+  const seen = new Set;
+  const models = [];
+  for (const option of flattenCursorAcpSelectOptions(modelConfig.options)) {
+    if (option.value === "default[]" || seen.has(option.value))
+      continue;
+    if (models.length >= RUNTIME_MODEL_CATALOG_MAX)
+      return;
+    seen.add(option.value);
+    models.push({
+      id: option.value,
+      ...option.name ? { displayName: option.name } : {},
+      supportedReasoningEfforts: []
+    });
+  }
+  return models.length > 0 ? { updateMode: "unsupported", models } : undefined;
+}
+async function cleanupProbeProcess(process3) {
+  if (process3.pid) {
+    await killProcessTree(process3.pid, { graceMs: 250 }).catch(() => {});
+    return;
+  }
+  if (process3.exitCode === null && process3.signalCode === null)
+    process3.kill("SIGTERM");
+}
+async function probeCursorAcpCatalog(command, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const spec = resolveSpawnSpec("cursor-agent", ["acp"], command);
+  let processHandle;
+  try {
+    processHandle = (options.spawn ?? spawnAgentProcess)(spec.command, spec.args, {
+      cwd,
+      env: { ...process.env, CI: "1" },
+      shell: spec.shell
+    });
+  } catch {
+    return;
+  }
+  return new Promise((resolve2) => {
+    let settled = false;
+    let buffer = "";
+    let outputBytes = 0;
+    let requestId = 0;
+    let expectedId = 0;
+    let expectedMethod = "";
+    const finish = (catalog) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const cleanup = options.cleanup ?? cleanupProbeProcess;
+      Promise.resolve().then(() => cleanup(processHandle)).catch(() => {}).finally(() => resolve2(catalog));
+    };
+    const request = (method, params) => {
+      if (settled)
+        return;
+      const stdin = processHandle.stdin;
+      if (!stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false)
+        return finish();
+      expectedId = ++requestId;
+      expectedMethod = method;
+      try {
+        stdin.write(`${jsonRpcRequest(method, params, expectedId)}
+`);
+      } catch {
+        finish();
+      }
+    };
+    const onLine = (line) => {
+      const parsed = tryParseJsonLine(line);
+      const message2 = record2(parsed);
+      if (!message2)
+        return finish();
+      if (message2.id !== expectedId)
+        return;
+      if (message2.error !== undefined)
+        return finish();
+      if (!Object.prototype.hasOwnProperty.call(message2, "result"))
+        return finish();
+      if (expectedMethod === "authenticate") {
+        request("session/new", { cwd, mcpServers: [] });
+        return;
+      }
+      const result = record2(message2.result);
+      if (!result)
+        return finish();
+      if (expectedMethod === "initialize") {
+        const authMethods = Array.isArray(result.authMethods) ? result.authMethods : [];
+        if (result.protocolVersion !== ACP_PROTOCOL_VERSION || !authMethods.some((method) => record2(method)?.id === AUTH_METHOD_ID))
+          return finish();
+        request("authenticate", { methodId: AUTH_METHOD_ID });
+        return;
+      }
+      if (expectedMethod !== "session/new" || typeof result.sessionId !== "string" || !result.sessionId.trim())
+        return finish();
+      finish(parseCursorAcpModelCatalog(result));
+    };
+    const timer = setTimeout(() => finish(), options.timeoutMs ?? CATALOG_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    processHandle.stdout?.on("data", (chunk2) => {
+      if (settled)
+        return;
+      const text2 = chunk2.toString();
+      outputBytes += Buffer.byteLength(text2);
+      if (outputBytes > (options.outputMaxBytes ?? CATALOG_PROBE_OUTPUT_MAX_BYTES))
+        return finish();
+      buffer += text2;
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines)
+        if (line.trim())
+          onLine(line);
+    });
+    processHandle.stderr?.on("data", (chunk2) => {
+      if (settled)
+        return;
+      outputBytes += Buffer.byteLength(chunk2.toString());
+      if (outputBytes > (options.outputMaxBytes ?? CATALOG_PROBE_OUTPUT_MAX_BYTES))
+        finish();
+    });
+    processHandle.on("error", () => finish());
+    processHandle.on("exit", () => finish());
+    request("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      },
+      clientInfo: { name: "alook-agent-driver-probe", version: "0.1.25" }
+    });
+  });
+}
+
+// agent-driver/dist/adapters/cursor/acp-lane.js
+var ACP_PROTOCOL_VERSION2 = 1;
+var HANDSHAKE_TIMEOUT_MS = 15000;
+var AUTH_METHOD_ID2 = "cursor_login";
 var PROMPT_STOP_REASONS = new Set([
   "end_turn",
   "max_tokens",
@@ -21807,16 +22080,16 @@ class CursorAcpRpcError extends Error {
     this.code = code;
   }
 }
-function record2(value) {
+function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeLabel(value) {
   return typeof value === "string" && /^[a-z0-9_-]{1,64}$/i.test(value) ? value : "unknown";
 }
 function rpcErrorMessage(error51) {
-  const payload = record2(error51);
+  const payload = record3(error51);
   const message2 = typeof payload?.message === "string" && payload.message.trim() ? payload.message : "Cursor ACP request failed";
-  const data = record2(payload?.data);
+  const data = record3(payload?.data);
   const detail = typeof data?.message === "string" && data.message.trim() ? data.message : undefined;
   return detail ? `${message2}: ${detail}` : message2;
 }
@@ -21824,26 +22097,6 @@ function isMissingSessionError(error51) {
   const message2 = error51 instanceof Error ? error51.message : String(error51);
   return /\bsession\b.*\b(not found|missing|unknown|invalid)\b/i.test(message2) || /\b(not found|missing|unknown|invalid)\b.*\bsession\b/i.test(message2);
 }
-function flattenSelectOptions(value) {
-  if (!Array.isArray(value))
-    return [];
-  const out = [];
-  for (const item of value) {
-    if (Array.isArray(item)) {
-      out.push(...flattenSelectOptions(item));
-      continue;
-    }
-    const candidate = record2(item);
-    if (!candidate)
-      continue;
-    if (typeof candidate.value === "string") {
-      out.push({ value: candidate.value, ...typeof candidate.name === "string" ? { name: candidate.name } : {} });
-    }
-    if (Array.isArray(candidate.options))
-      out.push(...flattenSelectOptions(candidate.options));
-  }
-  return out;
-}
 
 class CursorAcpLane {
   factory;
@@ -21967,30 +22220,30 @@ class CursorAcpLane {
     }
   }
   async handshake(ctx) {
-    const initialize = record2(await this.call("initialize", {
-      protocolVersion: ACP_PROTOCOL_VERSION,
+    const initialize = record3(await this.call("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION2,
       clientCapabilities: {
         fs: { readTextFile: false, writeTextFile: false },
         terminal: false
       },
       clientInfo: { name: "alook-agent-driver", version: "0.1.14" }
     }));
-    if (initialize?.protocolVersion !== ACP_PROTOCOL_VERSION) {
+    if (initialize?.protocolVersion !== ACP_PROTOCOL_VERSION2) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support protocol version 1");
     }
-    const capabilities = record2(initialize.agentCapabilities);
+    const capabilities = record3(initialize.agentCapabilities);
     if (capabilities?.loadSession !== true) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support persistent session loading");
     }
     const authMethods = Array.isArray(initialize.authMethods) ? initialize.authMethods : [];
-    if (!authMethods.some((method) => record2(method)?.id === AUTH_METHOD_ID)) {
+    if (!authMethods.some((method) => record3(method)?.id === AUTH_METHOD_ID2)) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not expose Cursor login authentication");
     }
-    await this.call("authenticate", { methodId: AUTH_METHOD_ID });
+    await this.call("authenticate", { methodId: AUTH_METHOD_ID2 });
     let session2;
     if (ctx.config.sessionId) {
       try {
-        session2 = record2(await this.call("session/load", {
+        session2 = record3(await this.call("session/load", {
           sessionId: ctx.config.sessionId,
           cwd: ctx.workingDirectory,
           mcpServers: []
@@ -22002,15 +22255,25 @@ class CursorAcpLane {
         throw error51;
       }
     } else {
-      session2 = record2(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
+      session2 = record3(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
     }
-    if (!session2 || typeof session2.sessionId !== "string" || !session2.sessionId.trim()) {
+    if (!session2)
+      throw new Error("Cursor ACP did not return a valid session response");
+    const returnedSessionId = session2.sessionId;
+    if (returnedSessionId !== undefined && (typeof returnedSessionId !== "string" || !returnedSessionId.trim())) {
       throw new Error("Cursor ACP did not return a valid session id");
     }
-    if (ctx.config.sessionId && session2.sessionId !== ctx.config.sessionId) {
-      throw new CursorAcpResetRequiredError("Cursor ACP loaded a different session; reset this agent before continuing");
+    if (ctx.config.sessionId) {
+      if (returnedSessionId !== undefined && returnedSessionId !== ctx.config.sessionId) {
+        throw new CursorAcpResetRequiredError("Cursor ACP loaded a different session; reset this agent before continuing");
+      }
+      this.sessionId = ctx.config.sessionId;
+    } else {
+      if (typeof returnedSessionId !== "string") {
+        throw new Error("Cursor ACP did not return a valid session id");
+      }
+      this.sessionId = returnedSessionId;
     }
-    this.sessionId = session2.sessionId;
     await this.configureModel(session2, ctx);
   }
   async configureModel(session2, ctx) {
@@ -22018,24 +22281,30 @@ class CursorAcpLane {
     if (!requestedModel)
       return;
     const configOptions = Array.isArray(session2.configOptions) ? session2.configOptions : [];
-    const modelConfig = configOptions.map(record2).find((option) => option?.id === "model") ?? null;
+    const modelConfig = configOptions.map(record3).find((option) => option?.id === "model") ?? null;
     if (!modelConfig) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support model configuration");
     }
-    const options = flattenSelectOptions(modelConfig.options);
-    const match = options.find((option) => option.value === requestedModel) ?? options.find((option) => option.name === requestedModel);
+    const options = flattenCursorAcpSelectOptions(modelConfig.options);
+    const match = options.find((option) => option.value === requestedModel);
     if (!match) {
       throw new CursorAcpIncompatibleError(`Configured Cursor model is unavailable through ACP: ${requestedModel}`);
     }
+    let response;
     try {
-      await this.call("session/set_config_option", {
+      response = record3(await this.call("session/set_config_option", {
         sessionId: this.sessionId,
         configId: "model",
         value: match.value
-      });
+      }));
     } catch {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP rejected model configuration");
     }
+    const confirmedOptions = Array.isArray(response?.configOptions) ? response.configOptions : [];
+    const confirmedModel = confirmedOptions.map(record3).find((option) => option?.id === "model") ?? null;
+    if (confirmedModel?.currentValue !== match.value) {
+      throw new CursorAcpIncompatibleError("Cursor ACP did not confirm the exact configured model");
+    }
   }
   admitPrompt(text2) {
     if (!this.sessionId)
@@ -22071,7 +22340,7 @@ class CursorAcpLane {
   completePrompt(active, value) {
     if (this.activePrompt?.requestId !== active.requestId)
       return;
-    const result = record2(value);
+    const result = record3(value);
     if (!result || typeof result.stopReason !== "string" || !PROMPT_STOP_REASONS.has(result.stopReason)) {
       this.failPrompt(active, new Error("Cursor ACP prompt response did not contain a supported stopReason"));
       return;
@@ -22213,7 +22482,7 @@ class CursorAcpLane {
     });
   }
   handleMessage(value) {
-    const message2 = record2(value);
+    const message2 = record3(value);
     if (!message2 || message2.jsonrpc !== "2.0") {
       this.protocolFailure("Cursor ACP emitted an invalid JSON-RPC message");
       return;
@@ -22241,7 +22510,7 @@ class CursorAcpLane {
     if (pending.kind === "prompt") {
       this.pending.delete(id);
       if (message2.error !== undefined) {
-        const payload = record2(message2.error);
+        const payload = record3(message2.error);
         this.failPrompt(pending.active, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message2.error)));
       } else if (!("result" in message2)) {
         this.failPrompt(pending.active, new Error("Cursor ACP response omitted result"));
@@ -22251,7 +22520,7 @@ class CursorAcpLane {
       return;
     }
     if (message2.error !== undefined) {
-      const payload = record2(message2.error);
+      const payload = record3(message2.error);
       this.settleRequest(id, false, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message2.error)));
       return;
     }
@@ -22283,9 +22552,9 @@ class CursorAcpLane {
       this.diagnostic("warning", `Unsupported Cursor ACP client request: ${safeLabel(method)}`);
       return;
     }
-    const payload = record2(params);
+    const payload = record3(params);
     const sameSession = payload?.sessionId === this.sessionId;
-    const options = Array.isArray(payload?.options) ? payload.options.map(record2).filter(Boolean) : [];
+    const options = Array.isArray(payload?.options) ? payload.options.map(record3).filter(Boolean) : [];
     const allowOnce = options.find((option) => option.kind === "allow_once" && typeof option.optionId === "string" && option.optionId.trim().length > 0);
     if (!this.ready || !this.activePrompt || !sameSession || !allowOnce) {
       this.write({ jsonrpc: "2.0", id, result: { outcome: { outcome: "cancelled" } } });
@@ -22306,7 +22575,7 @@ class CursorAcpLane {
     this.diagnostic("warning", `Unsupported Cursor ACP notification: ${safeLabel(method)}`);
   }
   handleSessionUpdate(params) {
-    const payload = record2(params);
+    const payload = record3(params);
     if (!payload || payload.sessionId !== this.sessionId) {
       this.diagnostic("warning", "Cursor ACP emitted an update for a different session");
       return;
@@ -22315,18 +22584,18 @@ class CursorAcpLane {
       this.diagnostic("warning", "Cursor ACP emitted a session update without an active prompt");
       return;
     }
-    const update = record2(payload.update) ?? {};
+    const update = record3(payload.update) ?? {};
     const updateType = update?.sessionUpdate;
     switch (updateType) {
       case "agent_message_chunk": {
-        const content = record2(update.content);
+        const content = record3(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
           this.events.emit("runtime_event", { kind: "assistant_message_delta", text: content.text });
         }
         return;
       }
       case "agent_thought_chunk": {
-        const content = record2(update.content);
+        const content = record3(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
           this.events.emit("runtime_event", { kind: "assistant_reasoning_delta", text: content.text });
         }
@@ -22398,6 +22667,7 @@ class CursorAcpLane {
 
 // agent-driver/dist/adapters/cursor/index.js
 class CursorDriver {
+  catalogProbe;
   id = "cursor";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -22406,8 +22676,23 @@ class CursorDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
-  probe(command) {
-    return probeCliRuntime("cursor-agent", {}, command);
+  constructor(catalogProbe = probeCursorAcpCatalog) {
+    this.catalogProbe = catalogProbe;
+  }
+  async probe(command) {
+    const result = probeCliRuntime("cursor-agent", {}, command);
+    if (result.status !== "healthy")
+      return result;
+    let reasoning;
+    try {
+      reasoning = await this.catalogProbe(command);
+    } catch {
+      reasoning = undefined;
+    }
+    return {
+      ...result,
+      reasoning
+    };
   }
   async openLane(ctx, options) {
     return new CursorAcpLane(this, ctx, { onRawStdoutLine: options?.onRawStdoutLine });
@@ -22464,7 +22749,7 @@ class OpenCodeHttpError extends Error {
     this.status = status;
   }
 }
-function record3(value) {
+function record4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeLabel2(value) {
@@ -22511,7 +22796,7 @@ function parseModelRef(model) {
   return { providerID: model.slice(0, slash), id: model.slice(slash + 1) };
 }
 function messageFromError(value) {
-  const payload = record3(value);
+  const payload = record4(value);
   const message2 = typeof payload?.message === "string" && payload.message.trim() ? payload.message : undefined;
   return message2 ? "OpenCode turn failed" : "OpenCode reported an inconsistent turn outcome";
 }
@@ -22845,7 +23130,7 @@ class OpenCodeServiceLane {
         const healthTimeoutMs = Math.max(1, Math.min(1000, deadline - Date.now(), this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS));
         const { response, body } = await this.fetchJsonWithTimeout("/global/health", { method: "GET" }, "health", healthTimeoutMs);
         if (response.ok) {
-          const health = record3(body);
+          const health = record4(body);
           if (health?.healthy !== true || health.version !== SUPPORTED_VERSION) {
             throw new OpenCodeIncompatibleError(`Installed OpenCode service must be version ${SUPPORTED_VERSION}`);
           }
@@ -22866,8 +23151,8 @@ class OpenCodeServiceLane {
     const { response, body } = await this.fetchJsonWithTimeout("/doc", { method: "GET" }, "OpenAPI");
     if (!response.ok)
       throw new OpenCodeIncompatibleError("Installed OpenCode service does not expose its OpenAPI document");
-    const document = record3(body);
-    const paths = record3(document?.paths);
+    const document = record4(body);
+    const paths = record4(document?.paths);
     const required2 = [
       "/api/session",
       "/api/session/active",
@@ -22880,7 +23165,7 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required2.some((path7) => !record3(paths[path7]))) {
+    if (!paths || required2.some((path7) => !record4(paths[path7]))) {
       throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
     }
   }
@@ -22893,7 +23178,7 @@ class OpenCodeServiceLane {
       }
       if (!response2.ok)
         throw new OpenCodeHttpError(response2.status, "session resume");
-      const session3 = record3(record3(body2)?.data);
+      const session3 = record4(record4(body2)?.data);
       if (session3?.id !== resumeId) {
         throw new OpenCodeResetRequiredError("OpenCode v2 returned a different resumed session; reset this agent before continuing");
       }
@@ -22914,8 +23199,8 @@ class OpenCodeServiceLane {
     }, "session create");
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, "session create");
-    const payload = record3(responseBody);
-    const session2 = record3(payload?.data);
+    const payload = record4(responseBody);
+    const session2 = record4(payload?.data);
     if (typeof session2?.id !== "string" || !/^ses/.test(session2.id)) {
       throw new Error("OpenCode v2 did not return a valid session id");
     }
@@ -23072,7 +23357,7 @@ class OpenCodeServiceLane {
         const { response, body: responseBody } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/history?after=${historyCursor}&limit=${HISTORY_PAGE_LIMIT}`, { method: "GET" }, "session history");
         if (!response.ok)
           throw new OpenCodeHttpError(response.status, "session history");
-        const body = record3(responseBody);
+        const body = record4(responseBody);
         if (!Array.isArray(body?.data) || typeof body.hasMore !== "boolean") {
           throw new OpenCodeProtocolError("OpenCode session history returned an invalid page");
         }
@@ -23090,9 +23375,9 @@ class OpenCodeServiceLane {
     return run;
   }
   async handleDurableEvent(value, project) {
-    const event = record3(value);
-    const durable = record3(event?.durable);
-    const data = record3(event?.data);
+    const event = record4(value);
+    const durable = record4(event?.durable);
+    const data = record4(event?.data);
     if (!event || typeof event.id !== "string" || typeof event.type !== "string" || !durable || durable.aggregateID !== this.sessionId || !Number.isInteger(durable.seq) || Number(durable.seq) < 0 || data?.sessionID !== this.sessionId) {
       throw new OpenCodeProtocolError("OpenCode session stream emitted an invalid durable event");
     }
@@ -23182,9 +23467,9 @@ class OpenCodeServiceLane {
             ...!successful ? { message: "OpenCode reported an unsupported final step outcome" } : {}
           });
         }
-        const tokens = record3(data.tokens);
+        const tokens = record4(data.tokens);
         if (tokens && data.finish !== "tool-calls") {
-          const cache = record3(tokens.cache);
+          const cache = record4(tokens.cache);
           const metric2 = (value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0 ? value2 : null;
           const cacheParts = [cache?.read, cache?.write].filter((value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0);
           const cacheTotal = cacheParts.reduce((sum, value2) => sum + value2, 0);
@@ -23211,8 +23496,8 @@ class OpenCodeServiceLane {
     return seq;
   }
   async handleLiveEvent(value) {
-    const event = record3(value);
-    const data = record3(event?.data);
+    const event = record4(value);
+    const data = record4(event?.data);
     if (event?.type !== "permission.v2.asked" || data?.sessionID !== this.sessionId)
       return;
     if (typeof data.id !== "string" || !/^per/.test(data.id)) {
@@ -23226,11 +23511,11 @@ class OpenCodeServiceLane {
     const { response, body: responseBody } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/permission`, { method: "GET" }, "permission list");
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, "permission list");
-    const body = record3(responseBody);
+    const body = record4(responseBody);
     if (!Array.isArray(body?.data))
       throw new OpenCodeProtocolError("OpenCode permission list returned invalid data");
     for (const item of body.data) {
-      const permission = record3(item);
+      const permission = record4(item);
       if (permission?.sessionID === this.sessionId && typeof permission.id === "string") {
         await this.replyPermission(permission.id);
       }
@@ -23297,8 +23582,8 @@ class OpenCodeServiceLane {
       }, "prompt admission");
       if (!response.ok)
         throw new OpenCodeHttpError(response.status, "prompt admission");
-      const body = record3(responseBody);
-      const admitted = record3(body?.data);
+      const body = record4(responseBody);
+      const admitted = record4(body?.data);
       if (admitted?.id !== messageId || admitted.sessionID !== this.sessionId || admitted.delivery !== delivery || !Number.isInteger(admitted.admittedSeq) || Number(admitted.admittedSeq) < 0) {
         throw new OpenCodeProtocolError("OpenCode prompt admission returned an invalid receipt");
       }
@@ -23365,8 +23650,8 @@ class OpenCodeServiceLane {
       const { response, body: responseBody } = await this.fetchJsonWithTimeout("/api/session/active", { method: "GET" }, "active session query");
       if (!response.ok)
         throw new OpenCodeHttpError(response.status, "active session query");
-      const body = record3(responseBody);
-      const active = record3(body?.data);
+      const body = record4(responseBody);
+      const active = record4(body?.data);
       if (!active)
         throw new OpenCodeProtocolError("OpenCode active session query returned invalid data");
       if (!this.barrierStillCurrent(root, identity, generation))
@@ -23571,6 +23856,7 @@ function createOpenCodeMessageId() {
 }
 
 class OpenCodeDriver {
+  outputProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -23579,8 +23865,19 @@ class OpenCodeDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
+  constructor(outputProbe = probeCommandOutput) {
+    this.outputProbe = outputProbe;
+  }
   probe(command) {
-    return probeCliRuntime("opencode", {}, command);
+    const result = probeCliRuntime("opencode", {}, command);
+    if (result.status !== "healthy")
+      return result;
+    const spec = resolveSpawnSpec("opencode", ["models", "--pure"], command);
+    const output = this.outputProbe(spec.command, spec.args);
+    return {
+      ...result,
+      reasoning: output.ok ? parseOpenCodeModelCatalog(output.output) : undefined
+    };
   }
   beginTurn() {
     return createOpenCodeMessageId();
@@ -23834,6 +24131,7 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
 
 // agent-driver/dist/adapters/pi/index.js
 var PI_SDK_PACKAGE_NAME2 = "@earendil-works/pi-coding-agent";
+var PI_MODEL_PROBE_TIMEOUT_MS = 5000;
 function isPiSdkPackageJson(pkgJsonPath) {
   if (!existsSync3(pkgJsonPath))
     return false;
@@ -23942,6 +24240,8 @@ function mapPiSdkEvent(event, sessionId, state) {
 
 class PiDriver {
   dependenciesFor;
+  loadSdk;
+  readVersion;
   id = "pi";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -23952,15 +24252,36 @@ class PiDriver {
   };
   sessionId = null;
   terminalSequence = 0;
-  constructor(dependenciesFor = createPiSessionDependencies) {
+  constructor(dependenciesFor = createPiSessionDependencies, loadSdk = loadPiSdkModule, readVersion = readPiSdkVersion) {
     this.dependenciesFor = dependenciesFor;
+    this.loadSdk = loadSdk;
+    this.readVersion = readVersion;
   }
-  probe() {
-    const version3 = readPiSdkVersion();
+  async probe() {
+    const version3 = this.readVersion();
     if (!version3) {
       return { status: "unhealthy", lastError: "sdk_not_installed" };
     }
-    return { status: "healthy", version: version3 };
+    let timer;
+    try {
+      const reasoning = await Promise.race([
+        this.loadSdk().then(async (sdk) => {
+          const authStorage = sdk.AuthStorage.create();
+          const registry2 = sdk.ModelRegistry.create(authStorage);
+          return parsePiModelCatalog(await registry2.getAvailable());
+        }),
+        new Promise((resolve3) => {
+          timer = setTimeout(() => resolve3(undefined), PI_MODEL_PROBE_TIMEOUT_MS);
+          timer.unref?.();
+        })
+      ]);
+      return { status: "healthy", version: version3, reasoning };
+    } catch {
+      return { status: "healthy", version: version3, reasoning: undefined };
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
   }
   async openLane(ctx) {
     const deps = this.dependenciesFor(ctx);
@@ -25868,14 +26189,14 @@ function createLogger2(options = {}) {
 `));
   const err = options.err ?? ((line) => process.stderr.write(line + `
 `));
-  const record4 = options.record;
+  const record5 = options.record;
   const emit = (level, message2, data) => {
     if (LEVEL_RANK[level] < minRank)
       return;
     const time3 = now();
     const line = `${time3} ${header} ${level.toUpperCase().padEnd(5)} ${message2}${formatData(data)}`;
     try {
-      record4?.({ time: time3, header, level, message: message2, fields: recordFields(data) });
+      record5?.({ time: time3, header, level, message: message2, fields: recordFields(data) });
     } catch {}
     (level === "warn" || level === "error" ? err : out)(line);
   };
@@ -27019,20 +27340,20 @@ function parseLocalMessageReminderBody(body, agentId) {
   }
   if (!value || typeof value !== "object" || Array.isArray(value))
     return null;
-  const record4 = value;
-  if (Object.keys(record4).sort().join(",") !== "channel,remindAfterMs,sentSeq")
+  const record5 = value;
+  if (Object.keys(record5).sort().join(",") !== "channel,remindAfterMs,sentSeq")
     return null;
-  if (typeof record4.channel !== "string" || !isCanonicalChannelScope(record4.channel))
+  if (typeof record5.channel !== "string" || !isCanonicalChannelScope(record5.channel))
     return null;
-  if (!Number.isSafeInteger(record4.sentSeq) || record4.sentSeq < 1)
+  if (!Number.isSafeInteger(record5.sentSeq) || record5.sentSeq < 1)
     return null;
-  if (!Number.isSafeInteger(record4.remindAfterMs) || record4.remindAfterMs !== 0 && record4.remindAfterMs < LOCAL_MESSAGE_REMINDER_MIN_MS || record4.remindAfterMs > LOCAL_MESSAGE_REMINDER_MAX_MS)
+  if (!Number.isSafeInteger(record5.remindAfterMs) || record5.remindAfterMs !== 0 && record5.remindAfterMs < LOCAL_MESSAGE_REMINDER_MIN_MS || record5.remindAfterMs > LOCAL_MESSAGE_REMINDER_MAX_MS)
     return null;
   return {
     agentId,
-    channel: record4.channel,
-    sentSeq: record4.sentSeq,
-    remindAfterMs: record4.remindAfterMs
+    channel: record5.channel,
+    sentSeq: record5.sentSeq,
+    remindAfterMs: record5.remindAfterMs
   };
 }
 async function handleLocalMessageReminder(req, res, agentId, onArm) {
@@ -27378,13 +27699,13 @@ function reduceManager(state, event) {
       const existing = state.agents[event.agentId];
       if (!existing || existing.execution.sessionInstanceId !== event.sessionInstanceId)
         return { state, effects: [] };
-      const record4 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
-      if (!record4)
+      const record5 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
+      if (!record5)
         return { state, effects: [] };
       const agent2 = clone2(existing);
       agent2.pendingAdmissions = agent2.pendingAdmissions.filter((entry) => entry.sessionInstanceId !== event.sessionInstanceId || entry.commandId !== event.commandId);
       syncExecutionProjection(agent2);
-      return commit(state, agent2, event.outcome === "failed" ? recoveryEffects(agent2, [record4]) : []);
+      return commit(state, agent2, event.outcome === "failed" ? recoveryEffects(agent2, [record5]) : []);
     }
     case "admission_acknowledged": {
       const existing = state.agents[event.agentId];
@@ -27902,11 +28223,11 @@ function syncExecutionProjection(agent2) {
   agent2.lastDeliverAt = agent2.pendingAdmissions.length > 0 ? Math.max(...agent2.pendingAdmissions.map((entry) => entry.admittedAt)) : null;
 }
 function recoveryEffects(agent2, records) {
-  return records.filter((record4) => record4.requeueOnFailure).map((record4) => ({
+  return records.filter((record5) => record5.requeueOnFailure).map((record5) => ({
     type: "requeue_delivery",
     agentId: agent2.agentId,
-    message: record4.exactAgentMsg,
-    mode: record4.mode
+    message: record5.exactAgentMsg,
+    mode: record5.mode
   }));
 }
 function commit(state, agent2, effects) {
@@ -28052,8 +28373,8 @@ async function readClaudeQuota(options) {
   if (!body || typeof body !== "object") {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
-  const record4 = body;
-  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record4[key])).filter((limit) => limit !== null);
+  const record5 = body;
+  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record5[key])).filter((limit) => limit !== null);
   if (limits.length === 0) {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
@@ -30228,11 +30549,10 @@ class AgentRouter {
       return;
     if (existing.status === "healthy" && !existing.lastError && !existing.lastErrorAt)
       return;
-    this.runtimes.set(id, {
-      id: existing.id,
-      version: existing.version,
-      status: "healthy"
-    });
+    const healthy = { ...existing, status: "healthy" };
+    delete healthy.lastError;
+    delete healthy.lastErrorAt;
+    this.runtimes.set(id, healthy);
     this.log.info("runtime marked healthy again", { runtimeId: id });
     this.scheduleReadyFrameResend();
   }
@@ -31813,15 +32133,15 @@ class MessageReminderScheduler {
     const startedAt = this.now();
     const dueAt = startedAt + input.remindAfterMs;
     const sentRef = `${input.channel}#${input.sentSeq}`;
-    const record4 = {
+    const record5 = {
       ...input,
       sentRef,
       startedAt,
       dueAt,
       timer: undefined
     };
-    record4.timer = this.setTimer(() => {
-      if (this.reminders.get(key) !== record4)
+    record5.timer = this.setTimer(() => {
+      if (this.reminders.get(key) !== record5)
         return;
       this.reminders.delete(key);
       try {
@@ -31832,8 +32152,8 @@ class MessageReminderScheduler {
         Promise.resolve(delivery).catch(() => {});
       } catch {}
     }, input.remindAfterMs);
-    record4.timer.unref?.();
-    this.reminders.set(key, record4);
+    record5.timer.unref?.();
+    this.reminders.set(key, record5);
     return { armed: true, dueAt };
   }
   observe(agentId, channel2, latestSeq) {
@@ -34128,11 +34448,11 @@ async function strictOutcome(response, allowed) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
       return { kind: "retryable" };
     }
-    const record4 = value;
-    if (Object.keys(record4).length !== 2 || record4.kind !== "terminal") {
+    const record5 = value;
+    if (Object.keys(record5).length !== 2 || record5.kind !== "terminal") {
       return { kind: "retryable" };
     }
-    const status = record4.status;
+    const status = record5.status;
     if (status !== "uploaded" && status !== "failed" || allowed[status] !== response.status) {
       return { kind: "retryable" };
     }
@@ -34626,7 +34946,7 @@ function createDaemonProcessLogger(daemonDir, foreground) {
 `) : quiet,
     err: foreground ? (line2) => process.stderr.write(line2 + `
 `) : quiet,
-    record: (record4) => sink.write(JSON.stringify(record4))
+    record: (record5) => sink.write(JSON.stringify(record5))
   });
   return { logger, logPath, sink };
 }
@@ -35369,18 +35689,18 @@ function readCredentialFile(filePath) {
   } catch {}
   return null;
 }
-function writeCredentialFile(filePath, record4) {
-  writePrivateJsonAtomic2(filePath, record4);
+function writeCredentialFile(filePath, record5) {
+  writePrivateJsonAtomic2(filePath, record5);
 }
 function readDaemonLaunchRecord(baseDir, machineId) {
-  const record4 = readCredentialFile(credentialFilePathByMachineId(baseDir, machineId));
-  if (!record4 || !("schemaVersion" in record4) || record4.schemaVersion !== 1 || !parseReleaseVersion(record4.daemonVersion)) {
+  const record5 = readCredentialFile(credentialFilePathByMachineId(baseDir, machineId));
+  if (!record5 || !("schemaVersion" in record5) || record5.schemaVersion !== 1 || !parseReleaseVersion(record5.daemonVersion)) {
     throw new Error("daemon launch record is missing or requires a manual start upgrade");
   }
-  validateMachineId(record4.machineId);
-  if (record4.machineId !== machineId)
+  validateMachineId(record5.machineId);
+  if (record5.machineId !== machineId)
     throw new Error("daemon launch record machine mismatch");
-  return record4;
+  return record5;
 }
 function findExistingCredentialForBearer(baseDir, bearer) {
   const dir = daemonsDir(baseDir);
@@ -35545,23 +35865,23 @@ async function daemonResume(opts) {
   if (!/^[A-Za-z0-9_-]{16,128}$/.test(opts.requestId))
     throw new Error("invalid replacement request id");
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
-  const record4 = readDaemonLaunchRecord(baseDir, opts.id);
+  const record5 = readDaemonLaunchRecord(baseDir, opts.id);
   if (false) {}
   await daemonStart({
-    machineKey: record4.credential,
-    serverUrl: record4.serverUrl,
-    wsUrl: record4.wsUrl,
+    machineKey: record5.credential,
+    serverUrl: record5.serverUrl,
+    wsUrl: record5.wsUrl,
     baseDir,
     resumeRequestId: opts.requestId
   });
 }
 async function daemonStartById(opts) {
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
-  const record4 = readDaemonLaunchRecord(baseDir, opts.id);
+  const record5 = readDaemonLaunchRecord(baseDir, opts.id);
   await daemonStart({
-    machineKey: record4.credential,
-    serverUrl: record4.serverUrl,
-    wsUrl: record4.wsUrl,
+    machineKey: record5.credential,
+    serverUrl: record5.serverUrl,
+    wsUrl: record5.wsUrl,
     baseDir,
     foreground: opts.foreground
   });