@alook/daemon 0.1.25 → 0.1.26

package/dist/index.js

@@ -942,8 +942,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;
@@ -1278,6 +1278,7 @@ import { execFileSync as execFileSync2 } from "child_process";
 import * as fs4 from "fs";
 import * as path4 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);
@@ -1328,6 +1329,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 path4.join(deps.homeDir || process.env.HOME || ".", relativePath);
 }
@@ -1434,6 +1452,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"] };
@@ -1450,10 +1476,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 });
@@ -2020,10 +2047,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(message) {
   return /\bno\s+rollout\s+found\b/i.test(message) || /\bmissing\s+rollout\b/i.test(message) || /\brollout\b.*\b(not found|missing)\b/i.test(message) || /\b(not found|missing)\b.*\brollout\b/i.test(message);
@@ -2099,11 +2175,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)
@@ -2121,12 +2199,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) => {
@@ -2170,9 +2252,15 @@ class CodexDriver {
         const result = message.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 } : {},
@@ -2182,7 +2270,11 @@ class CodexDriver {
       const timer = setTimeout(() => finish(), MODEL_LIST_TIMEOUT_MS);
       timer.unref?.();
       proc.stdout?.on("data", (chunk) => {
-        buffer += chunk.toString();
+        const text = chunk.toString();
+        outputBytes += Buffer.byteLength(text);
+        if (outputBytes > MODEL_LIST_OUTPUT_MAX_BYTES)
+          return finish();
+        buffer += text;
         const lines = buffer.split(`
 `);
         buffer = lines.pop() ?? "";
@@ -2385,9 +2477,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 record(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 = record(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(session) {
+  const payload = record(session);
+  const configOptions = Array.isArray(payload?.configOptions) ? payload.configOptions : [];
+  const modelConfig = configOptions.map(record).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(process2) {
+  if (process2.pid) {
+    await killProcessTree(process2.pid, { graceMs: 250 }).catch(() => {});
+    return;
+  }
+  if (process2.exitCode === null && process2.signalCode === null)
+    process2.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 message = record(parsed);
+      if (!message)
+        return finish();
+      if (message.id !== expectedId)
+        return;
+      if (message.error !== undefined)
+        return finish();
+      if (!Object.prototype.hasOwnProperty.call(message, "result"))
+        return finish();
+      if (expectedMethod === "authenticate") {
+        request("session/new", { cwd, mcpServers: [] });
+        return;
+      }
+      const result = record(message.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) => record(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", (chunk) => {
+      if (settled)
+        return;
+      const text = chunk.toString();
+      outputBytes += Buffer.byteLength(text);
+      if (outputBytes > (options.outputMaxBytes ?? CATALOG_PROBE_OUTPUT_MAX_BYTES))
+        return finish();
+      buffer += text;
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines)
+        if (line.trim())
+          onLine(line);
+    });
+    processHandle.stderr?.on("data", (chunk) => {
+      if (settled)
+        return;
+      outputBytes += Buffer.byteLength(chunk.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",
@@ -2411,16 +2683,16 @@ class CursorAcpRpcError extends Error {
     this.code = code;
   }
 }
-function record(value) {
+function record2(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(error) {
-  const payload = record(error);
+  const payload = record2(error);
   const message = typeof payload?.message === "string" && payload.message.trim() ? payload.message : "Cursor ACP request failed";
-  const data = record(payload?.data);
+  const data = record2(payload?.data);
   const detail = typeof data?.message === "string" && data.message.trim() ? data.message : undefined;
   return detail ? `${message}: ${detail}` : message;
 }
@@ -2428,26 +2700,6 @@ function isMissingSessionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /\bsession\b.*\b(not found|missing|unknown|invalid)\b/i.test(message) || /\b(not found|missing|unknown|invalid)\b.*\bsession\b/i.test(message);
 }
-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 = record(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;
@@ -2571,30 +2823,30 @@ class CursorAcpLane {
     }
   }
   async handshake(ctx) {
-    const initialize = record(await this.call("initialize", {
-      protocolVersion: ACP_PROTOCOL_VERSION,
+    const initialize = record2(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 = record(initialize.agentCapabilities);
+    const capabilities = record2(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) => record(method)?.id === AUTH_METHOD_ID)) {
+    if (!authMethods.some((method) => record2(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 session;
     if (ctx.config.sessionId) {
       try {
-        session = record(await this.call("session/load", {
+        session = record2(await this.call("session/load", {
           sessionId: ctx.config.sessionId,
           cwd: ctx.workingDirectory,
           mcpServers: []
@@ -2606,15 +2858,25 @@ class CursorAcpLane {
         throw error;
       }
     } else {
-      session = record(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
+      session = record2(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
     }
-    if (!session || typeof session.sessionId !== "string" || !session.sessionId.trim()) {
+    if (!session)
+      throw new Error("Cursor ACP did not return a valid session response");
+    const returnedSessionId = session.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 && session.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 = session.sessionId;
     await this.configureModel(session, ctx);
   }
   async configureModel(session, ctx) {
@@ -2622,24 +2884,30 @@ class CursorAcpLane {
     if (!requestedModel)
       return;
     const configOptions = Array.isArray(session.configOptions) ? session.configOptions : [];
-    const modelConfig = configOptions.map(record).find((option) => option?.id === "model") ?? null;
+    const modelConfig = configOptions.map(record2).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 = record2(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(record2).find((option) => option?.id === "model") ?? null;
+    if (confirmedModel?.currentValue !== match.value) {
+      throw new CursorAcpIncompatibleError("Cursor ACP did not confirm the exact configured model");
+    }
   }
   admitPrompt(text) {
     if (!this.sessionId)
@@ -2675,7 +2943,7 @@ class CursorAcpLane {
   completePrompt(active, value) {
     if (this.activePrompt?.requestId !== active.requestId)
       return;
-    const result = record(value);
+    const result = record2(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;
@@ -2817,7 +3085,7 @@ class CursorAcpLane {
     });
   }
   handleMessage(value) {
-    const message = record(value);
+    const message = record2(value);
     if (!message || message.jsonrpc !== "2.0") {
       this.protocolFailure("Cursor ACP emitted an invalid JSON-RPC message");
       return;
@@ -2845,7 +3113,7 @@ class CursorAcpLane {
     if (pending.kind === "prompt") {
       this.pending.delete(id);
       if (message.error !== undefined) {
-        const payload = record(message.error);
+        const payload = record2(message.error);
         this.failPrompt(pending.active, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message.error)));
       } else if (!("result" in message)) {
         this.failPrompt(pending.active, new Error("Cursor ACP response omitted result"));
@@ -2855,7 +3123,7 @@ class CursorAcpLane {
       return;
     }
     if (message.error !== undefined) {
-      const payload = record(message.error);
+      const payload = record2(message.error);
       this.settleRequest(id, false, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message.error)));
       return;
     }
@@ -2887,9 +3155,9 @@ class CursorAcpLane {
       this.diagnostic("warning", `Unsupported Cursor ACP client request: ${safeLabel(method)}`);
       return;
     }
-    const payload = record(params);
+    const payload = record2(params);
     const sameSession = payload?.sessionId === this.sessionId;
-    const options = Array.isArray(payload?.options) ? payload.options.map(record).filter(Boolean) : [];
+    const options = Array.isArray(payload?.options) ? payload.options.map(record2).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" } } });
@@ -2910,7 +3178,7 @@ class CursorAcpLane {
     this.diagnostic("warning", `Unsupported Cursor ACP notification: ${safeLabel(method)}`);
   }
   handleSessionUpdate(params) {
-    const payload = record(params);
+    const payload = record2(params);
     if (!payload || payload.sessionId !== this.sessionId) {
       this.diagnostic("warning", "Cursor ACP emitted an update for a different session");
       return;
@@ -2919,18 +3187,18 @@ class CursorAcpLane {
       this.diagnostic("warning", "Cursor ACP emitted a session update without an active prompt");
       return;
     }
-    const update = record(payload.update) ?? {};
+    const update = record2(payload.update) ?? {};
     const updateType = update?.sessionUpdate;
     switch (updateType) {
       case "agent_message_chunk": {
-        const content = record(update.content);
+        const content = record2(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 = record(update.content);
+        const content = record2(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
           this.events.emit("runtime_event", { kind: "assistant_reasoning_delta", text: content.text });
         }
@@ -3002,6 +3270,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 = {
@@ -3010,8 +3279,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 });
@@ -3068,7 +3352,7 @@ class OpenCodeHttpError extends Error {
     this.status = status;
   }
 }
-function record2(value) {
+function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeLabel2(value) {
@@ -3115,7 +3399,7 @@ function parseModelRef(model) {
   return { providerID: model.slice(0, slash), id: model.slice(slash + 1) };
 }
 function messageFromError(value) {
-  const payload = record2(value);
+  const payload = record3(value);
   const message = typeof payload?.message === "string" && payload.message.trim() ? payload.message : undefined;
   return message ? "OpenCode turn failed" : "OpenCode reported an inconsistent turn outcome";
 }
@@ -3449,7 +3733,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 = record2(body);
+          const health = record3(body);
           if (health?.healthy !== true || health.version !== SUPPORTED_VERSION) {
             throw new OpenCodeIncompatibleError(`Installed OpenCode service must be version ${SUPPORTED_VERSION}`);
           }
@@ -3470,8 +3754,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 = record2(body);
-    const paths = record2(document?.paths);
+    const document = record3(body);
+    const paths = record3(document?.paths);
     const required = [
       "/api/session",
       "/api/session/active",
@@ -3484,7 +3768,7 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required.some((path6) => !record2(paths[path6]))) {
+    if (!paths || required.some((path6) => !record3(paths[path6]))) {
       throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
     }
   }
@@ -3497,7 +3781,7 @@ class OpenCodeServiceLane {
       }
       if (!response2.ok)
         throw new OpenCodeHttpError(response2.status, "session resume");
-      const session2 = record2(record2(body2)?.data);
+      const session2 = record3(record3(body2)?.data);
       if (session2?.id !== resumeId) {
         throw new OpenCodeResetRequiredError("OpenCode v2 returned a different resumed session; reset this agent before continuing");
       }
@@ -3518,8 +3802,8 @@ class OpenCodeServiceLane {
     }, "session create");
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, "session create");
-    const payload = record2(responseBody);
-    const session = record2(payload?.data);
+    const payload = record3(responseBody);
+    const session = record3(payload?.data);
     if (typeof session?.id !== "string" || !/^ses/.test(session.id)) {
       throw new Error("OpenCode v2 did not return a valid session id");
     }
@@ -3676,7 +3960,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 = record2(responseBody);
+        const body = record3(responseBody);
         if (!Array.isArray(body?.data) || typeof body.hasMore !== "boolean") {
           throw new OpenCodeProtocolError("OpenCode session history returned an invalid page");
         }
@@ -3694,9 +3978,9 @@ class OpenCodeServiceLane {
     return run;
   }
   async handleDurableEvent(value, project) {
-    const event = record2(value);
-    const durable = record2(event?.durable);
-    const data = record2(event?.data);
+    const event = record3(value);
+    const durable = record3(event?.durable);
+    const data = record3(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");
     }
@@ -3786,9 +4070,9 @@ class OpenCodeServiceLane {
             ...!successful ? { message: "OpenCode reported an unsupported final step outcome" } : {}
           });
         }
-        const tokens = record2(data.tokens);
+        const tokens = record3(data.tokens);
         if (tokens && data.finish !== "tool-calls") {
-          const cache = record2(tokens.cache);
+          const cache = record3(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);
@@ -3815,8 +4099,8 @@ class OpenCodeServiceLane {
     return seq;
   }
   async handleLiveEvent(value) {
-    const event = record2(value);
-    const data = record2(event?.data);
+    const event = record3(value);
+    const data = record3(event?.data);
     if (event?.type !== "permission.v2.asked" || data?.sessionID !== this.sessionId)
       return;
     if (typeof data.id !== "string" || !/^per/.test(data.id)) {
@@ -3830,11 +4114,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 = record2(responseBody);
+    const body = record3(responseBody);
     if (!Array.isArray(body?.data))
       throw new OpenCodeProtocolError("OpenCode permission list returned invalid data");
     for (const item of body.data) {
-      const permission = record2(item);
+      const permission = record3(item);
       if (permission?.sessionID === this.sessionId && typeof permission.id === "string") {
         await this.replyPermission(permission.id);
       }
@@ -3901,8 +4185,8 @@ class OpenCodeServiceLane {
       }, "prompt admission");
       if (!response.ok)
         throw new OpenCodeHttpError(response.status, "prompt admission");
-      const body = record2(responseBody);
-      const admitted = record2(body?.data);
+      const body = record3(responseBody);
+      const admitted = record3(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");
       }
@@ -3969,8 +4253,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 = record2(responseBody);
-      const active = record2(body?.data);
+      const body = record3(responseBody);
+      const active = record3(body?.data);
       if (!active)
         throw new OpenCodeProtocolError("OpenCode active session query returned invalid data");
       if (!this.barrierStillCurrent(root, identity, generation))
@@ -4175,6 +4459,7 @@ function createOpenCodeMessageId() {
 }
 
 class OpenCodeDriver {
+  outputProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -4183,8 +4468,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();
@@ -4438,6 +4734,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;
@@ -4546,6 +4843,8 @@ function mapPiSdkEvent(event, sessionId, state) {
 
 class PiDriver {
   dependenciesFor;
+  loadSdk;
+  readVersion;
   id = "pi";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -4556,15 +4855,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 version = readPiSdkVersion();
+  async probe() {
+    const version = this.readVersion();
     if (!version) {
       return { status: "unhealthy", lastError: "sdk_not_installed" };
     }
-    return { status: "healthy", version };
+    let timer;
+    try {
+      const reasoning = await Promise.race([
+        this.loadSdk().then(async (sdk) => {
+          const authStorage = sdk.AuthStorage.create();
+          const registry = sdk.ModelRegistry.create(authStorage);
+          return parsePiModelCatalog(await registry.getAvailable());
+        }),
+        new Promise((resolve3) => {
+          timer = setTimeout(() => resolve3(undefined), PI_MODEL_PROBE_TIMEOUT_MS);
+          timer.unref?.();
+        })
+      ]);
+      return { status: "healthy", version, reasoning };
+    } catch {
+      return { status: "healthy", version, reasoning: undefined };
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
   }
   async openLane(ctx) {
     const deps = this.dependenciesFor(ctx);
@@ -6596,8 +6916,8 @@ async function readClaudeQuota(options) {
   if (!body || typeof body !== "object") {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
-  const record3 = body;
-  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record3[key])).filter((limit) => limit !== null);
+  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);
   if (limits.length === 0) {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
@@ -7254,10 +7574,10 @@ function stableNormalizeApmHeldFreshness(value) {
     return value.map((item) => stableNormalizeApmHeldFreshness(item));
   if (!value || typeof value !== "object")
     return value;
-  const record3 = value;
+  const record4 = value;
   const normalized = {};
-  for (const key of Object.keys(record3).sort()) {
-    normalized[key] = stableNormalizeApmHeldFreshness(record3[key]);
+  for (const key of Object.keys(record4).sort()) {
+    normalized[key] = stableNormalizeApmHeldFreshness(record4[key]);
   }
   return normalized;
 }
@@ -7373,13 +7693,13 @@ function reduceManager(state, event) {
       const existing = state.agents[event.agentId];
       if (!existing || existing.execution.sessionInstanceId !== event.sessionInstanceId)
         return { state, effects: [] };
-      const record3 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
-      if (!record3)
+      const record4 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
+      if (!record4)
         return { state, effects: [] };
       const agent = clone(existing);
       agent.pendingAdmissions = agent.pendingAdmissions.filter((entry) => entry.sessionInstanceId !== event.sessionInstanceId || entry.commandId !== event.commandId);
       syncExecutionProjection(agent);
-      return commit(state, agent, event.outcome === "failed" ? recoveryEffects(agent, [record3]) : []);
+      return commit(state, agent, event.outcome === "failed" ? recoveryEffects(agent, [record4]) : []);
     }
     case "admission_acknowledged": {
       const existing = state.agents[event.agentId];
@@ -7897,11 +8217,11 @@ function syncExecutionProjection(agent) {
   agent.lastDeliverAt = agent.pendingAdmissions.length > 0 ? Math.max(...agent.pendingAdmissions.map((entry) => entry.admittedAt)) : null;
 }
 function recoveryEffects(agent, records) {
-  return records.filter((record3) => record3.requeueOnFailure).map((record3) => ({
+  return records.filter((record4) => record4.requeueOnFailure).map((record4) => ({
     type: "requeue_delivery",
     agentId: agent.agentId,
-    message: record3.exactAgentMsg,
-    mode: record3.mode
+    message: record4.exactAgentMsg,
+    mode: record4.mode
   }));
 }
 function commit(state, agent, effects) {
@@ -8312,14 +8632,14 @@ function createLogger(options = {}) {
 `));
   const err = options.err ?? ((line) => process.stderr.write(line + `
 `));
-  const record3 = options.record;
+  const record4 = options.record;
   const emit = (level, message, data) => {
     if (LEVEL_RANK[level] < minRank)
       return;
     const time = now();
     const line = `${time} ${header} ${level.toUpperCase().padEnd(5)} ${message}${formatData(data)}`;
     try {
-      record3?.({ time, header, level, message, fields: recordFields(data) });
+      record4?.({ time, header, level, message, fields: recordFields(data) });
     } catch {}
     (level === "warn" || level === "error" ? err : out)(line);
   };
@@ -10058,7 +10378,7 @@ __export(exports_external, {
   regexes: () => exports_regexes,
   regex: () => _regex,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   property: () => _property,
   promise: () => promise,
@@ -22214,7 +22534,7 @@ __export(exports_schemas2, {
   strictObject: () => strictObject,
   set: () => set,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   promise: () => promise,
   preprocess: () => preprocess,
@@ -23291,7 +23611,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
-function record3(keyType, valueType, params) {
+function record4(keyType, valueType, params) {
   if (!valueType || !valueType._zod) {
     return new ZodRecord({
       type: "record",
@@ -23756,7 +24076,7 @@ var stringbool = (...args) => _stringbool({
 }, ...args);
 function json(params) {
   const jsonSchema = lazy(() => {
-    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record3(string2(), jsonSchema)]);
+    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record4(string2(), jsonSchema)]);
   });
   return jsonSchema;
 }
@@ -26955,11 +27275,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();
   }
@@ -27379,20 +27698,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) {
@@ -28529,7 +28848,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,
@@ -28537,6 +28856,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) => {
@@ -32111,15 +32431,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 {
@@ -32130,8 +32450,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) {