chainlesschain 0.162.34 → 0.162.36

package/src/index.js

@@ -62,6 +62,10 @@ import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
+import { registerPermissionsCommand } from "./commands/permissions.js";
+import { registerOutputStyleCommand } from "./commands/output-style.js";
+import { registerStatuslineCommand } from "./commands/statusline.js";
+import { registerIdeCommand } from "./commands/ide.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
 import { registerExportCommand } from "./commands/export.js";
@@ -460,6 +464,10 @@ export function createProgram(opts = {}) {
   registerGoalCommand(program);
   registerCommandCommand(program);
   registerCompactCommand(program);
+  registerPermissionsCommand(program);
+  registerOutputStyleCommand(program);
+  registerStatuslineCommand(program);
+  registerIdeCommand(program);
   registerConsolCommand(program);
 
   // Phase 2: Knowledge & content management

package/src/lib/agent-core.js

@@ -24,5 +24,12 @@ export {
   agentLoop,
   formatToolArgs,
   getActiveMcpServers,
+  listBackgroundShellTasks,
+  killAllBackgroundShellTasks,
   _accumulateOllamaStream,
+  _accumulateOpenAIStream,
+  _accumulateAnthropicStream,
+  _toAnthropicMessages,
+  _anthropicThinkingParams,
+  _normalizeAnthropicResponse,
 } from "../runtime/agent-core.js";

package/src/lib/agents.js

@@ -0,0 +1,147 @@
+/**
+ * agents — user-defined subagent definitions (Claude-Code parity).
+ *
+ * Markdown files under `.claude/agents/` (project) or `~/.claude/agents/`
+ * (personal) define named subagents. Each file's body IS the subagent's system
+ * prompt; frontmatter declares its metadata. Mirrors `.claude/commands/` (see
+ * slash-commands.js) but for *agents* rather than prompt macros — a file
+ * `review/security.md` is the agent `review:security`.
+ *
+ * Frontmatter (all optional):
+ *   name          override the filename-derived name
+ *   description   one-line summary (when to use this agent)
+ *   tools         allow-list — comma string or YAML array; omit = inherit all
+ *   model         model override for runs of this agent
+ *
+ * Project scope shadows personal on a name clash. Discovery + parse are pure
+ * (inject fs/path/home) so the whole thing is unit-testable.
+ */
+
+import fsDefault from "node:fs";
+import pathDefault from "node:path";
+import { homedir } from "node:os";
+import yaml from "js-yaml";
+
+const _deps = { fs: fsDefault, path: pathDefault };
+
+/** Split `--- ... ---` YAML frontmatter from the body, camelCasing keys. */
+function parseFrontmatter(content) {
+  const text = String(content || "");
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return { data: {}, body: text.trim() };
+  let raw = {};
+  try {
+    raw = yaml.load(m[1]) || {};
+  } catch {
+    raw = {};
+  }
+  const data = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const camel = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    data[camel] = v;
+  }
+  return { data, body: (m[2] || "").trim() };
+}
+
+/** Normalize `tools` (comma string | array | null) into a string[] or null. */
+export function normalizeTools(tools) {
+  if (tools == null) return null;
+  const list = Array.isArray(tools)
+    ? tools
+    : String(tools).split(/[,\s]+/);
+  const out = list.map((t) => String(t).trim()).filter(Boolean);
+  return out.length > 0 ? out : null;
+}
+
+/** Directories scanned for agent files — project first (shadows personal). */
+export function agentDirs(cwd = process.cwd(), opts = {}) {
+  const path = opts.deps?.path || _deps.path;
+  const home = opts.home || homedir();
+  // Project-native first (highest precedence), then the Claude-Code-portable
+  // location (so existing `.claude/agents/*.md` work unchanged), then personal.
+  // discoverAgents reverses + last-write-wins, so `.chainlesschain/agents/`
+  // shadows `.claude/agents/` shadows `~/.claude/agents/` on a name clash.
+  return [
+    { dir: path.join(cwd, ".chainlesschain", "agents"), scope: "project" },
+    { dir: path.join(cwd, ".claude", "agents"), scope: "project" },
+    { dir: path.join(home, ".claude", "agents"), scope: "personal" },
+  ];
+}
+
+/** Recursively collect `*.md` files under `dir` as `{file, rel}` (rel uses /). */
+function walkMd(dir, { fs, path }, base = dir, acc = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      walkMd(full, { fs, path }, base, acc);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const rel = path.relative(base, full).replace(/\\/g, "/");
+      acc.push({ file: full, rel });
+    }
+  }
+  return acc;
+}
+
+/** Agent name from a relative path: `review/security.md` → `review:security`. */
+function nameFromRel(rel) {
+  return rel.replace(/\.md$/, "").replace(/\//g, ":");
+}
+
+/** Parse one agent file into its metadata + system prompt (the body). */
+export function parseAgentFile(file, scope, opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(content);
+  return {
+    file,
+    scope,
+    name: data.name || null, // resolved against the path in discoverAgents
+    description: data.description || "",
+    tools: normalizeTools(data.tools),
+    model: data.model || null,
+    systemPrompt: body || "",
+  };
+}
+
+/**
+ * Discover all agents across both scopes. Project shadows personal by name.
+ * @returns {Array<{name, scope, file, description, tools, model, systemPrompt}>}
+ */
+export function discoverAgents(cwd = process.cwd(), opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  const path = opts.deps?.path || _deps.path;
+  const byName = new Map();
+  // Personal first, then project — so project overwrites on clash.
+  const dirs = agentDirs(cwd, opts).reverse();
+  for (const { dir, scope } of dirs) {
+    for (const { file, rel } of walkMd(dir, { fs, path })) {
+      const meta = parseAgentFile(file, scope, opts);
+      if (!meta) continue;
+      // Explicit frontmatter `name` wins; else derive from the path.
+      const name = meta.name || nameFromRel(rel);
+      byName.set(name, { ...meta, name });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Look up one agent by name (accepts `review:security` or `review/security`). */
+export function getAgent(name, cwd = process.cwd(), opts = {}) {
+  const wanted = String(name || "")
+    .replace(/^\//, "")
+    .replace(/\//g, ":");
+  return discoverAgents(cwd, opts).find((a) => a.name === wanted) || null;
+}
+
+export { _deps };

package/src/lib/hook-manager.js

@@ -40,6 +40,7 @@ export const HookEvents = {
   SessionEnd: "SessionEnd",
   PreCompact: "PreCompact",
   PostCompact: "PostCompact",
+  Notification: "Notification",
   UserPromptSubmit: "UserPromptSubmit",
   AssistantResponse: "AssistantResponse",
   AgentStart: "AgentStart",

package/src/lib/hook-runner.cjs

@@ -0,0 +1,183 @@
+"use strict";
+
+/**
+ * hook-runner — execute a Claude-Code `command` hook with the JSON protocol.
+ *
+ * Protocol (Claude-Code parity):
+ *   - the hook event payload is written to the command's STDIN as JSON;
+ *   - exit code 2          → BLOCK (reason = stderr) — the canonical "deny" path;
+ *   - exit code 0 + JSON stdout → honored decision:
+ *       { "decision": "block"|"approve"|"ask", "reason": "..." }
+ *       { "hookSpecificOutput": { "permissionDecision": "deny"|"allow"|"ask",
+ *                                 "permissionDecisionReason": "..." } }
+ *       { "continue": false, "stopReason": "..." }                → block
+ *       { "additionalContext": "..." }                            → continue
+ *   - any other non-zero   → non-blocking error (surfaced, never blocks);
+ *   - spawn failure / timeout → non-blocking (a broken hook must not wedge the
+ *                               agent — only an explicit block decision blocks).
+ *
+ * Returns a normalized `{ decision, reason, exitCode, stdout, stderr, ... }`.
+ * `_deps.spawnSync` is injected for unit tests (no real process needed).
+ */
+
+const cpDefault = require("node:child_process");
+
+const _deps = { spawnSync: cpDefault.spawnSync };
+
+const HOOK_DECISIONS = Object.freeze({
+  BLOCK: "block",
+  ALLOW: "allow",
+  ASK: "ask",
+  CONTINUE: "continue",
+});
+
+/** Parse a hook's stdout JSON into a normalized decision, or null if not JSON. */
+function tryParseDecision(stdout) {
+  const text = String(stdout || "").trim();
+  if (!text || text[0] !== "{") return null;
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  // PreToolUse-specific permission decision
+  const hso = obj.hookSpecificOutput;
+  if (hso && hso.permissionDecision) {
+    const pd = String(hso.permissionDecision).toLowerCase();
+    const decision =
+      pd === "deny"
+        ? HOOK_DECISIONS.BLOCK
+        : pd === "ask"
+          ? HOOK_DECISIONS.ASK
+          : pd === "allow"
+            ? HOOK_DECISIONS.ALLOW
+            : HOOK_DECISIONS.CONTINUE;
+    return { decision, reason: hso.permissionDecisionReason || null };
+  }
+  // Generic decision field
+  if (obj.decision) {
+    const d = String(obj.decision).toLowerCase();
+    const decision =
+      d === "block" || d === "deny"
+        ? HOOK_DECISIONS.BLOCK
+        : d === "approve" || d === "allow"
+          ? HOOK_DECISIONS.ALLOW
+          : d === "ask"
+            ? HOOK_DECISIONS.ASK
+            : HOOK_DECISIONS.CONTINUE;
+    return { decision, reason: obj.reason || null };
+  }
+  // continue:false → stop/block
+  if (obj.continue === false) {
+    return {
+      decision: HOOK_DECISIONS.BLOCK,
+      reason: obj.stopReason || obj.reason || "hook requested stop",
+    };
+  }
+  return {
+    decision: HOOK_DECISIONS.CONTINUE,
+    reason: null,
+    additionalContext: obj.additionalContext || null,
+  };
+}
+
+/**
+ * Run one command hook. `input` is JSON-serialized to the hook's stdin.
+ *
+ * @param {string} command
+ * @param {object} [input]   the hook event payload (tool_name, tool_input, …)
+ * @param {object} [opts]    { timeout=60000, cwd, event }
+ * @returns {{ decision:string, reason:string|null, exitCode:number|null,
+ *            stdout?:string, stderr?:string, additionalContext?:string,
+ *            nonBlockingError?:boolean, error?:string }}
+ */
+function runCommandHook(command, input = {}, opts = {}) {
+  const { timeout = 60000, cwd, event } = opts;
+  if (!command) {
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
+  }
+  let res;
+  try {
+    res = _deps.spawnSync(command, {
+      input: JSON.stringify(input),
+      cwd: cwd || process.cwd(),
+      encoding: "utf-8",
+      timeout,
+      shell: true,
+      maxBuffer: 8 * 1024 * 1024,
+      env: {
+        ...process.env,
+        CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
+      },
+    });
+  } catch (err) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook spawn failed: ${err.message}`,
+      exitCode: null,
+      error: err.message,
+      nonBlockingError: true,
+    };
+  }
+  // spawnSync surfaces timeout/ENOENT on res.error (status null) — non-blocking.
+  if (res.error) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook error: ${res.error.message}`,
+      exitCode: null,
+      stdout: String(res.stdout || ""),
+      stderr: String(res.stderr || ""),
+      error: res.error.message,
+      nonBlockingError: true,
+    };
+  }
+  const exitCode = res.status;
+  const stdout = String(res.stdout || "");
+  const stderr = String(res.stderr || "");
+
+  if (exitCode === 2) {
+    return {
+      decision: HOOK_DECISIONS.BLOCK,
+      reason: stderr.trim() || "hook exited 2 (blocked)",
+      exitCode,
+      stdout,
+      stderr,
+    };
+  }
+  if (exitCode === 0) {
+    const parsed = tryParseDecision(stdout);
+    if (parsed) return { ...parsed, exitCode, stdout, stderr };
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode, stdout, stderr };
+  }
+  // Other non-zero → non-blocking error.
+  return {
+    decision: HOOK_DECISIONS.CONTINUE,
+    reason: stderr.trim() || `hook exited ${exitCode}`,
+    exitCode,
+    stdout,
+    stderr,
+    nonBlockingError: true,
+  };
+}
+
+/**
+ * Run a list of command hooks in order; first BLOCK (or ASK) short-circuits.
+ * @returns {{ decision, reason, hook?, results }}
+ */
+function runHooks(commandHooks, input = {}, opts = {}) {
+  const results = [];
+  for (const h of commandHooks || []) {
+    const r = runCommandHook(h.command, input, {
+      ...opts,
+      timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+    });
+    results.push({ command: h.command, ...r });
+    if (r.decision === HOOK_DECISIONS.BLOCK || r.decision === HOOK_DECISIONS.ASK) {
+      return { decision: r.decision, reason: r.reason, hook: h.command, results };
+    }
+  }
+  return { decision: HOOK_DECISIONS.CONTINUE, reason: null, results };
+}
+
+module.exports = { runCommandHook, runHooks, tryParseDecision, HOOK_DECISIONS, _deps };

package/src/lib/ide-bridge.js

@@ -0,0 +1,310 @@
+/**
+ * IDE bridge discovery (Phase 0) — find a first-party IDE MCP server that an
+ * editor extension advertises via a lockfile, and turn it into an MCP server
+ * config the agent loop can connect to.
+ *
+ * Protocol (design: docs/design/modules/98_IDE桥接对标方案.md): each running
+ * IDE instance writes
+ *     ~/.chainlesschain/ide/<port>.json     (file 0600, dir 0700)
+ * describing a localhost SSE/HTTP MCP server + a per-instance bearer token.
+ * The extension that owns the integrated terminal ALSO injects
+ *     CHAINLESSCHAIN_IDE_PORT   (+ optional CHAINLESSCHAIN_IDE_TOKEN)
+ * so the CLI can lock onto the exact instance without scanning/guessing
+ * (the deterministic "path A" below). Plain terminals fall back to a lockfile
+ * scan + workspace match ("path B").
+ *
+ * Phase 0 is pure CLI: no extension code, no VS Code dependency, fully
+ * unit-testable through `_deps`. The connect path itself reuses the existing
+ * MCP client (SSE/HTTP) via mcp-config.js `loadIdeMcp`.
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+/** A lock whose pid is dead and whose file is older than this = stale. */
+const STALE_TTL_MS = 30_000;
+
+/** Transports the CLI's MCP client can actually talk (see mcp-client.js). */
+const SUPPORTED_TRANSPORTS = new Set(["sse", "http", "https"]);
+
+/** Liveness probe via signal 0 — cross-platform (works on Windows too). */
+function defaultProcessAlive(pid) {
+  if (!pid || typeof pid !== "number") return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM: the process exists but we may not signal it → still alive.
+    return !!(err && err.code === "EPERM");
+  }
+}
+
+export const _deps = {
+  readDir: (d) => fs.readdirSync(d),
+  readFile: (p) => fs.readFileSync(p, "utf-8"),
+  statMtimeMs: (p) => fs.statSync(p).mtimeMs,
+  homedir: () => os.homedir(),
+  now: () => Date.now(),
+  processAlive: defaultProcessAlive,
+};
+
+/** `~/.chainlesschain/ide/`. */
+export function ideLockDir(deps = _deps) {
+  return path.join(deps.homedir(), ".chainlesschain", "ide");
+}
+
+function isLocalhostUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname === "127.0.0.1" || u.hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function inferTransportFromUrl(url) {
+  if (/\/sse(\b|\/|$)/i.test(url)) return "sse";
+  if (/^https:/i.test(url)) return "https";
+  if (/^http:/i.test(url)) return "http";
+  return null;
+}
+
+/** Parse + validate one lock JSON. Returns a normalized lock or null. */
+function parseLock(raw, filePath) {
+  let lock;
+  try {
+    lock = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!lock || typeof lock !== "object") return null;
+  if (!lock.url || !isLocalhostUrl(lock.url)) return null;
+
+  const transport = String(
+    lock.transport || inferTransportFromUrl(lock.url) || "",
+  ).toLowerCase();
+  if (!SUPPORTED_TRANSPORTS.has(transport)) return null; // e.g. ws — not yet
+
+  let folders = lock.workspaceFolders;
+  if (typeof folders === "string") folders = [folders];
+  if (!Array.isArray(folders)) folders = [];
+  folders = folders.filter((f) => typeof f === "string" && f.length > 0);
+
+  return {
+    ide: typeof lock.ide === "string" ? lock.ide : "unknown",
+    transport,
+    url: lock.url,
+    port: lock.port,
+    token: typeof lock.token === "string" ? lock.token : null,
+    workspaceFolders: folders,
+    pid: typeof lock.pid === "number" ? lock.pid : null,
+    startedAt: typeof lock.started_at === "number" ? lock.started_at : 0,
+    _file: filePath,
+  };
+}
+
+/** True when a lock is dead: pid gone AND file older than the TTL. */
+function isStale(lock, deps) {
+  if (lock.pid && deps.processAlive(lock.pid)) return false;
+  let mtime;
+  try {
+    mtime = deps.statMtimeMs(lock._file);
+  } catch {
+    return true;
+  }
+  return deps.now() - mtime > STALE_TTL_MS;
+}
+
+/**
+ * Scan the lock dir → normalized, live, localhost, supported-transport locks.
+ * Missing dir / unreadable files are silently skipped (best-effort).
+ */
+export function readIdeLocks(deps = _deps) {
+  const dir = ideLockDir(deps);
+  let names;
+  try {
+    names = deps.readDir(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names || []) {
+    if (!String(name).endsWith(".json")) continue;
+    const fp = path.join(dir, name);
+    let raw;
+    try {
+      raw = deps.readFile(fp);
+    } catch {
+      continue;
+    }
+    const lock = parseLock(raw, fp);
+    if (!lock) continue;
+    if (isStale(lock, deps)) continue;
+    out.push(lock);
+  }
+  return out;
+}
+
+/** Are we running inside an editor's integrated terminal? */
+export function isInIdeTerminal(env = process.env) {
+  if (!env) return false;
+  if (env.CHAINLESSCHAIN_IDE_PORT) return true;
+  if (env.TERM_PROGRAM === "vscode") return true;
+  if (env.CHAINLESSCHAIN_IDE) return true;
+  if (env.TERMINAL_EMULATOR && /jetbrains/i.test(env.TERMINAL_EMULATOR)) {
+    return true;
+  }
+  return false;
+}
+
+/** Normalize a path for prefix comparison (sep + trailing slash + win case). */
+function normPath(p) {
+  const s = String(p)
+    .replace(/\\/g, "/")
+    .replace(/\/+$/, "");
+  return process.platform === "win32" ? s.toLowerCase() : s;
+}
+
+/**
+ * Longest matching workspace-folder length for `cwd`, or -1 if none of the
+ * lock's folders contains (or equals) cwd. Longer = more specific.
+ */
+function workspaceMatchScore(lock, cwd) {
+  const c = normPath(cwd);
+  let best = -1;
+  for (const f of lock.workspaceFolders) {
+    const nf = normPath(f);
+    if (c === nf || c.startsWith(nf + "/")) {
+      if (nf.length > best) best = nf.length;
+    }
+  }
+  return best;
+}
+
+/**
+ * Pick the IDE server to connect to, or null.
+ *
+ * Path A (deterministic): if `CHAINLESSCHAIN_IDE_PORT` is set and a live lock
+ *   has that port, use it (token may come from the lock or the env).
+ * Path B (scan): otherwise rank live locks by (longest workspace-prefix match,
+ *   then newest started_at). With `force`, fall back to the newest lock even
+ *   when no folder matches (used by `--ide`).
+ *
+ * @param {object} opts { cwd?, env?, force? }
+ * @param {object} [deps]
+ */
+export function discoverIdeServer(
+  { cwd = process.cwd(), env = process.env, force = false } = {},
+  deps = _deps,
+) {
+  const locks = readIdeLocks(deps);
+  if (!locks.length) return null;
+
+  // Path A — env fast-path.
+  const envPort = env && env.CHAINLESSCHAIN_IDE_PORT;
+  if (envPort) {
+    const hit = locks.find((l) => String(l.port) === String(envPort));
+    if (hit) {
+      if (!hit.token && env.CHAINLESSCHAIN_IDE_TOKEN) {
+        hit.token = env.CHAINLESSCHAIN_IDE_TOKEN;
+      }
+      return hit;
+    }
+    // env named a port with no live lock — fall through to scan.
+  }
+
+  // Path B — workspace match.
+  let best = null;
+  let bestScore = -1;
+  let bestStarted = -1;
+  for (const l of locks) {
+    const score = workspaceMatchScore(l, cwd);
+    if (score < 0) continue;
+    if (
+      score > bestScore ||
+      (score === bestScore && l.startedAt > bestStarted)
+    ) {
+      best = l;
+      bestScore = score;
+      bestStarted = l.startedAt;
+    }
+  }
+  if (best) return best;
+
+  // --ide forced but no workspace match → newest live lock.
+  if (force) {
+    return locks
+      .slice()
+      .sort((a, b) => b.startedAt - a.startedAt)[0];
+  }
+  return null;
+}
+
+/**
+ * A discovered lock → an MCP server config row for `setupMcpFromConfig`.
+ * `longRunning` is forward-compat metadata: IDE tools like `ide_openDiff` may
+ * block on the user for minutes, so the agent loop should exempt them from a
+ * per-call timeout (consumed in Phase 1).
+ */
+export function ideServerToMcpConfig(lock) {
+  if (!lock || !lock.url) return null;
+  const headers = {};
+  if (lock.token) headers.Authorization = `Bearer ${lock.token}`;
+  return {
+    url: lock.url,
+    transport: lock.transport,
+    headers,
+    longRunning: true,
+  };
+}
+
+/**
+ * Human-readable explanation of why discovery did/didn't find a server — backs
+ * `cc ide doctor`. Returns { inIdeTerminal, locks:[{...,reasons?}], chosen,
+ * reason }.
+ */
+export function diagnoseIde(
+  { cwd = process.cwd(), env = process.env, force = false } = {},
+  deps = _deps,
+) {
+  const inIdeTerminal = isInIdeTerminal(env);
+  const locks = readIdeLocks(deps);
+  const chosen = discoverIdeServer({ cwd, env, force }, deps);
+
+  let reason;
+  if (chosen) {
+    reason = env && env.CHAINLESSCHAIN_IDE_PORT &&
+      String(chosen.port) === String(env.CHAINLESSCHAIN_IDE_PORT)
+      ? "matched CHAINLESSCHAIN_IDE_PORT (env fast-path)"
+      : force
+        ? "forced (--ide); newest live lock"
+        : "workspace match";
+  } else if (!locks.length) {
+    reason =
+      "no live IDE lockfiles in " +
+      ideLockDir(deps) +
+      " (is an IDE extension running? are locks stale?)";
+  } else {
+    reason =
+      "lockfiles present but none match cwd's workspace " +
+      "(run with --ide to force the newest, or cd into the IDE workspace)";
+  }
+  return {
+    inIdeTerminal,
+    lockDir: ideLockDir(deps),
+    locks: locks.map((l) => ({
+      ide: l.ide,
+      port: l.port,
+      transport: l.transport,
+      url: l.url,
+      hasToken: !!l.token,
+      workspaceFolders: l.workspaceFolders,
+      pid: l.pid,
+      matchScore: workspaceMatchScore(l, cwd),
+    })),
+    chosen: chosen
+      ? { ide: chosen.ide, port: chosen.port, url: chosen.url }
+      : null,
+    reason,
+  };
+}