larkin 0.2.70

package/dist/platform/workspace-service.mjs

@@ -0,0 +1,430 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import processInspect from "./process-inspect.cjs";
+const START = "<!-- larkin:platform-rules:start -->";
+const END = "<!-- larkin:platform-rules:end -->";
+const START_BYTES = Buffer.from(START, "ascii");
+const END_BYTES = Buffer.from(END, "ascii");
+const PROMPT_FILES = ["AGENTS.md", "CLAUDE.md"];
+const AGENT_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+const NOFOLLOW = fs.constants.O_NOFOLLOW || 0;
+const LOCK_FILE = "workspace-reconcile.lock.json";
+const LOCK_RETRY_ATTEMPTS = 100;
+const LOCK_RETRY_MS = 20;
+const MALFORMED_LOCK_GRACE_MS = 1_000;
+function isMissing(error) {
+    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+function identity(stat) {
+    return { dev: stat.dev, ino: stat.ino };
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function occurrences(content, marker) {
+    const found = [];
+    for (let at = content.indexOf(marker); at >= 0; at = content.indexOf(marker, at + marker.length))
+        found.push(at);
+    return found;
+}
+function promptMigration(content, file) {
+    const starts = occurrences(content, START_BYTES);
+    const ends = occurrences(content, END_BYTES);
+    if (starts.length === 0 && ends.length === 0)
+        return { next: content, spans: [] };
+    if (starts.length !== 1 || ends.length !== 1 || starts[0] > ends[0]) {
+        throw new Error(`managed prompt markers are malformed or duplicate: ${file}`);
+    }
+    const start = starts[0];
+    const length = ends[0] + END_BYTES.length - start;
+    const next = Buffer.from(content);
+    next.fill(0x20, start, start + length);
+    return { next, spans: [{ start, length }] };
+}
+function readStableFd(fd, label) {
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const before = fs.fstatSync(fd);
+        if (!before.isFile())
+            throw new Error(`prompt is no longer a regular file: ${label}`);
+        const size = before.size;
+        const content = Buffer.alloc(size);
+        let offset = 0;
+        while (offset < size) {
+            const read = fs.readSync(fd, content, offset, size - offset, offset);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        const after = fs.fstatSync(fd);
+        if (offset === size && after.size === size && after.mtimeMs === before.mtimeMs && after.ctimeMs === before.ctimeMs) {
+            return content;
+        }
+    }
+    throw new Error(`owner prompt remained under sustained concurrent writes: ${label}`);
+}
+function promptPlan(file) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
+    }
+    if (stat.isSymbolicLink())
+        throw new Error(`unsafe prompt symlink: ${file}`);
+    if (!stat.isFile())
+        throw new Error(`prompt path is not a regular file: ${file}`);
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | NOFOLLOW);
+    try {
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile() || !sameIdentity(identity(opened), identity(stat))) {
+            throw new Error(`prompt changed while opening: ${file}`);
+        }
+        const current = readStableFd(fd, file);
+        const migration = promptMigration(current, file);
+        return { file, current, ...migration, mode: opened.mode & 0o777, identity: identity(opened), fd };
+    }
+    catch (error) {
+        fs.closeSync(fd);
+        throw error;
+    }
+}
+function assertPromptUnchanged(plan) {
+    let stat;
+    try {
+        stat = fs.lstatSync(plan.file);
+    }
+    catch {
+        throw new Error(`owner prompt changed concurrently: ${plan.file}`);
+    }
+    if (stat.isSymbolicLink() || !stat.isFile() ||
+        !sameIdentity(identity(stat), plan.identity) || (stat.mode & 0o777) !== plan.mode) {
+        throw new Error(`owner prompt inode or mode changed concurrently: ${plan.file}`);
+    }
+    const opened = fs.fstatSync(plan.fd);
+    if (!opened.isFile() || !sameIdentity(identity(opened), plan.identity) || (opened.mode & 0o777) !== plan.mode) {
+        throw new Error(`owner prompt descriptor changed concurrently: ${plan.file}`);
+    }
+    const current = readStableFd(plan.fd, plan.file);
+    if (!current.equals(plan.current))
+        throw new Error(`owner prompt content changed concurrently: ${plan.file}`);
+}
+function directoryIdentity(file, label) {
+    const stat = fs.lstatSync(file);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw new Error(`${label} is no longer a stable directory: ${file}`);
+    return identity(stat);
+}
+function assertDirectoryIdentity(file, expected, label) {
+    let current;
+    try {
+        current = directoryIdentity(file, label);
+    }
+    catch {
+        throw new Error(`${label} changed during workspace reconciliation: ${file}`);
+    }
+    if (!sameIdentity(current, expected))
+        throw new Error(`${label} inode changed during workspace reconciliation: ${file}`);
+}
+function closePromptPlan(plan) {
+    try {
+        fs.closeSync(plan.fd);
+    }
+    catch { /* already closed during cleanup */ }
+}
+function writeManagedSpans(plan, beforeWrite) {
+    assertPromptUnchanged(plan);
+    const fd = fs.openSync(plan.file, fs.constants.O_RDWR | NOFOLLOW);
+    try {
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile() || !sameIdentity(identity(opened), plan.identity) || (opened.mode & 0o777) !== plan.mode) {
+            throw new Error(`owner prompt changed while opening for migration: ${plan.file}`);
+        }
+        beforeWrite?.(plan.file);
+        assertPromptUnchanged(plan);
+        const current = readStableFd(fd, plan.file);
+        if (!current.equals(plan.current))
+            throw new Error(`owner prompt content changed concurrently: ${plan.file}`);
+        for (const span of plan.spans) {
+            const blank = Buffer.alloc(span.length, 0x20);
+            let offset = 0;
+            while (offset < blank.length) {
+                const written = fs.writeSync(fd, blank, offset, blank.length - offset, span.start + offset);
+                if (written === 0)
+                    throw new Error(`managed prompt migration made no write progress: ${plan.file}`);
+                offset += written;
+            }
+        }
+        fs.fsyncSync(fd);
+        const after = fs.fstatSync(fd);
+        const canonical = fs.lstatSync(plan.file);
+        if (!after.isFile() || !sameIdentity(identity(after), plan.identity) || (after.mode & 0o777) !== plan.mode ||
+            after.size !== plan.current.length || canonical.isSymbolicLink() || !canonical.isFile() ||
+            !sameIdentity(identity(canonical), plan.identity) || canonical.size !== plan.current.length) {
+            throw new Error(`owner prompt inode, mode, or size changed during migration: ${plan.file}`);
+        }
+        const installed = readStableFd(fd, plan.file);
+        if (!installed.equals(plan.next))
+            throw new Error(`managed prompt migration readback mismatch: ${plan.file}`);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function lockRecord() {
+    const inspected = processInspect.inspectProcess(process.pid);
+    if (!inspected?.ok || !inspected.startToken) {
+        throw new Error(`workspace reconciliation cannot establish process ownership (${inspected?.reason || "inspection failed"})`);
+    }
+    return {
+        pid: process.pid,
+        processStartToken: inspected.startToken,
+        nonce: crypto.randomUUID(),
+        startedAt: new Date().toISOString(),
+    };
+}
+function isLockRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return Number.isInteger(record.pid) && Number(record.pid) > 0 &&
+        typeof record.processStartToken === "string" && record.processStartToken.length > 0 &&
+        typeof record.nonce === "string" && record.nonce.length > 0 &&
+        typeof record.startedAt === "string";
+}
+function createLockFile(file, record) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | NOFOLLOW, 0o600);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "EEXIST")
+            return null;
+        throw error;
+    }
+    try {
+        fs.fchmodSync(fd, 0o600);
+        fs.writeFileSync(fd, JSON.stringify(record) + "\n");
+        fs.fsyncSync(fd);
+        return identity(fs.fstatSync(fd));
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readLockSnapshot(file) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
+    }
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw new Error("workspace reconciliation lock path is unsafe");
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | NOFOLLOW);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
+    }
+    try {
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile() || !sameIdentity(identity(opened), identity(stat)))
+            return null;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(fs.readFileSync(fd, "utf8"));
+        }
+        catch { /* malformed/in-flight record */ }
+        return {
+            record: isLockRecord(parsed) ? parsed : null,
+            identity: identity(opened),
+            ageMs: Math.max(0, Date.now() - opened.mtimeMs),
+        };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function lockState(snapshot) {
+    if (!snapshot.record)
+        return snapshot.ageMs >= MALFORMED_LOCK_GRACE_MS ? "stale" : "unknown";
+    if (!processInspect.pidAlive(snapshot.record.pid))
+        return "stale";
+    const inspected = processInspect.inspectProcess(snapshot.record.pid);
+    if (!inspected?.ok || !inspected.startToken) {
+        return processInspect.pidAlive(snapshot.record.pid) ? "unknown" : "stale";
+    }
+    return inspected.startToken === snapshot.record.processStartToken ? "live" : "stale";
+}
+function unlinkIfIdentity(file, expected) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+    if (!stat.isFile() || !sameIdentity(identity(stat), expected))
+        return false;
+    fs.unlinkSync(file);
+    return true;
+}
+function tryAcquireReclaimGuard(file, record) {
+    let guardIdentity = createLockFile(file, record);
+    if (!guardIdentity) {
+        const existing = readLockSnapshot(file);
+        if (!existing || lockState(existing) !== "stale" || !unlinkIfIdentity(file, existing.identity))
+            return null;
+        guardIdentity = createLockFile(file, record);
+        if (!guardIdentity)
+            return null;
+    }
+    const ownedIdentity = guardIdentity;
+    return () => {
+        try {
+            const current = readLockSnapshot(file);
+            if (current?.record?.pid === record.pid && current.record.nonce === record.nonce &&
+                sameIdentity(current.identity, ownedIdentity))
+                unlinkIfIdentity(file, ownedIdentity);
+        }
+        catch { /* another owner or already removed */ }
+    };
+}
+function acquireWorkspaceLock(lockDirReal) {
+    const file = path.join(lockDirReal, LOCK_FILE);
+    const reclaimFile = path.join(lockDirReal, `${LOCK_FILE}.reclaim`);
+    const record = lockRecord();
+    let lastOwnerPid = null;
+    for (let attempt = 0; attempt < LOCK_RETRY_ATTEMPTS; attempt += 1) {
+        const ownedIdentity = createLockFile(file, record);
+        if (ownedIdentity) {
+            return () => {
+                try {
+                    const current = readLockSnapshot(file);
+                    if (current?.record?.pid === record.pid && current.record.nonce === record.nonce &&
+                        sameIdentity(current.identity, ownedIdentity))
+                        unlinkIfIdentity(file, ownedIdentity);
+                }
+                catch { /* another owner or already removed */ }
+            };
+        }
+        const observed = readLockSnapshot(file);
+        if (!observed)
+            continue;
+        lastOwnerPid = observed.record?.pid || null;
+        if (lockState(observed) === "stale") {
+            const releaseReclaim = tryAcquireReclaimGuard(reclaimFile, record);
+            if (releaseReclaim) {
+                try {
+                    const latest = readLockSnapshot(file);
+                    if (latest && lockState(latest) === "stale")
+                        unlinkIfIdentity(file, latest.identity);
+                }
+                finally {
+                    releaseReclaim();
+                }
+                continue;
+            }
+        }
+        sleepSync(LOCK_RETRY_MS);
+    }
+    throw new Error(`workspace reconciliation remained busy after bounded retry${lastOwnerPid ? ` (pid=${lastOwnerPid})` : ""}`);
+}
+export function reconcileAgentWorkspace(options) {
+    const { workspaceDir, trustedWorkspaceRoot, lockDir, agentId, testHooks } = options || {};
+    if (!AGENT_ID.test(agentId || "") || agentId === "." || agentId === ".." || /[\\/]/.test(agentId || "")) {
+        throw new Error(`invalid agent id: ${JSON.stringify(agentId)}`);
+    }
+    if (!workspaceDir || !trustedWorkspaceRoot || !lockDir) {
+        throw new Error("workspaceDir, trustedWorkspaceRoot, and lockDir are required");
+    }
+    const rootPath = path.resolve(trustedWorkspaceRoot);
+    const workspacePath = path.resolve(workspaceDir);
+    if (!inside(rootPath, workspacePath))
+        throw new Error(`workspace path escapes trusted workspace root: ${workspacePath}`);
+    fs.mkdirSync(rootPath, { recursive: true, mode: 0o700 });
+    if (!fs.statSync(rootPath).isDirectory())
+        throw new Error(`trusted workspace root is not a directory: ${rootPath}`);
+    let workspaceStat;
+    try {
+        workspaceStat = fs.lstatSync(workspacePath);
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+        fs.mkdirSync(workspacePath, { mode: 0o700 });
+        workspaceStat = fs.lstatSync(workspacePath);
+    }
+    if (workspaceStat.isSymbolicLink())
+        throw new Error(`workspace directory symlink is unsafe: ${workspacePath}`);
+    if (!fs.statSync(workspacePath).isDirectory())
+        throw new Error(`workspace is not a directory: ${workspacePath}`);
+    const rootReal = fs.realpathSync(rootPath);
+    const workspaceReal = fs.realpathSync(workspacePath);
+    if (!inside(rootReal, workspaceReal))
+        throw new Error(`workspace realpath is outside trusted workspace root: ${workspaceReal}`);
+    const lockDirPath = path.resolve(lockDir);
+    fs.mkdirSync(lockDirPath, { recursive: true, mode: 0o700 });
+    const lockDirReal = fs.realpathSync(lockDirPath);
+    if (lockDirReal === workspaceReal || inside(workspaceReal, lockDirReal)) {
+        throw new Error("workspace reconciliation lockDir must be outside the user workspace");
+    }
+    // From this point on, never traverse the mutable canonical bridge again. Capture stable directory identities,
+    // lock through the Agent's internal state directory, and re-check all directories before preflight/write.
+    const rootIdentity = directoryIdentity(rootReal, "trusted workspace root");
+    const workspaceIdentity = directoryIdentity(workspaceReal, "workspace");
+    const lockDirIdentity = directoryIdentity(lockDirReal, "workspace lock directory");
+    const releaseLock = acquireWorkspaceLock(lockDirReal);
+    const openPlans = [];
+    try {
+        assertDirectoryIdentity(rootReal, rootIdentity, "trusted workspace root");
+        assertDirectoryIdentity(workspaceReal, workspaceIdentity, "workspace");
+        assertDirectoryIdentity(lockDirReal, lockDirIdentity, "workspace lock directory");
+        const plans = PROMPT_FILES.map((name) => promptPlan(path.join(workspaceReal, name)))
+            .filter((plan) => plan !== null);
+        openPlans.push(...plans);
+        const changed = plans.filter((plan) => !plan.next.equals(plan.current));
+        assertDirectoryIdentity(rootReal, rootIdentity, "trusted workspace root");
+        assertDirectoryIdentity(workspaceReal, workspaceIdentity, "workspace");
+        assertDirectoryIdentity(lockDirReal, lockDirIdentity, "workspace lock directory");
+        for (const plan of plans)
+            assertPromptUnchanged(plan);
+        const writtenPlans = new Set();
+        for (const plan of changed) {
+            assertDirectoryIdentity(rootReal, rootIdentity, "trusted workspace root");
+            assertDirectoryIdentity(workspaceReal, workspaceIdentity, "workspace");
+            assertDirectoryIdentity(lockDirReal, lockDirIdentity, "workspace lock directory");
+            for (const pending of plans) {
+                if (!writtenPlans.has(pending))
+                    assertPromptUnchanged(pending);
+            }
+            writeManagedSpans(plan, testHooks?.beforeWrite);
+            writtenPlans.add(plan);
+        }
+        return { workspaceDir: workspaceReal, changed: changed.map((plan) => path.basename(plan.file)) };
+    }
+    finally {
+        for (const plan of openPlans)
+            closePromptPlan(plan);
+        releaseLock();
+    }
+}

package/dist/runtime/builtin-pi-assets.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+function privateDirectory(directory) {
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error(`unsafe bundled Pi asset directory: ${directory}`);
+    fs.chmodSync(directory, 0o700);
+}
+function writeEmbeddedFile(file, contents) {
+    const temporary = `${file}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    fs.writeFileSync(temporary, contents, { mode: 0o600, flag: "wx" });
+    fs.renameSync(temporary, file);
+    fs.chmodSync(file, 0o600);
+}
+/** Materialize upstream runtime assets that Bun cannot serve through ordinary fs paths. */
+export function prepareBuiltinPiPackageAssets() {
+    const assets = globalThis.__LARKIN_EMBEDDED_BUILTIN_PI_ASSETS__;
+    if (!assets)
+        return;
+    const agentDir = process.env.PI_CODING_AGENT_DIR;
+    if (!agentDir)
+        throw new Error("bundled Pi requires PI_CODING_AGENT_DIR");
+    privateDirectory(agentDir);
+    const packageDir = path.join(agentDir, ".larkin-official-pi-package");
+    const themeDir = path.join(packageDir, "theme");
+    privateDirectory(packageDir);
+    privateDirectory(themeDir);
+    writeEmbeddedFile(path.join(packageDir, "package.json"), assets.packageJson);
+    writeEmbeddedFile(path.join(themeDir, "dark.json"), assets.darkTheme);
+    writeEmbeddedFile(path.join(themeDir, "light.json"), assets.lightTheme);
+    process.env.PI_PACKAGE_DIR = packageDir;
+}

package/dist/runtime/claude-model-catalog.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverClaudeModelCatalog = discoverClaudeModelCatalog;
+const node_child_process_1 = require("node:child_process");
+const SAFE_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._\[\]-]{0,127}$/;
+const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
+function cleanText(value, fallback) {
+    if (typeof value !== "string")
+        return fallback;
+    return value.replace(/[\u0000-\u001f\u007f]+/g, "").replace(/\s+/g, " ").trim().slice(0, 120) || fallback;
+}
+async function runClaudeControl(call) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(call.command || "claude", call.args, { ...(call.cwd ? { cwd: call.cwd } : {}), env: call.env, stdio: ["pipe", "pipe", "pipe"] });
+        let settled = false;
+        let stdout = "";
+        let bytes = 0;
+        const requestId = String(call.request.request_id);
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGTERM");
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error("Claude model catalog timed out")), call.timeout);
+        timer.unref?.();
+        child.on("error", () => finish(new Error("Claude model catalog command failed")));
+        child.on("exit", () => finish(new Error("Claude model catalog control channel exited before response")));
+        child.stderr.resume();
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > call.maxBuffer)
+                return finish(new Error("Claude model catalog response exceeded limit"));
+            stdout += chunk.toString("utf8");
+            for (;;) {
+                const newline = stdout.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = stdout.slice(0, newline);
+                stdout = stdout.slice(newline + 1);
+                try {
+                    const message = JSON.parse(line);
+                    const response = message.response;
+                    if (message.type === "control_response" && response?.request_id === requestId) {
+                        if (response.subtype !== "success")
+                            return finish(new Error("Claude model catalog request failed"));
+                        return finish(undefined, response.response);
+                    }
+                }
+                catch { /* control channel is newline-delimited JSON; ignore unrelated messages */ }
+            }
+        });
+        child.stdin.write(`${JSON.stringify(call.request)}\n`);
+    });
+}
+function efforts(item) {
+    if (item.supportsEffort !== true || !Array.isArray(item.supportedEffortLevels))
+        return [];
+    return [...new Set(item.supportedEffortLevels.filter((level) => typeof level === "string" && EFFORT_LEVELS.has(level)))];
+}
+function parseCatalog(value) {
+    const rows = value?.models;
+    if (!Array.isArray(rows) || rows.length === 0 || rows.length > 128)
+        throw new Error("Claude model catalog has an invalid model list");
+    const defaultRow = rows.find((row) => row?.value === "default");
+    const effectiveModel = typeof defaultRow?.resolvedModel === "string" && SAFE_MODEL_ID.test(defaultRow.resolvedModel) ? defaultRow.resolvedModel : "";
+    const seen = new Set();
+    const models = rows.flatMap((row) => {
+        if (!row || typeof row !== "object" || Array.isArray(row))
+            return [];
+        const item = row;
+        const id = typeof item.value === "string" ? item.value : "";
+        if (id === "default" || !SAFE_MODEL_ID.test(id) || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{ id, label: cleanText(item.displayName, id), supportedReasoningEfforts: efforts(item), verified: "claude-control-visible" }];
+    });
+    if (!effectiveModel || !models.length)
+        throw new Error("Claude model catalog has no visible local default");
+    return { models, effectiveModel, defaultSupportedReasoningEfforts: efforts(defaultRow || {}) };
+}
+async function discoverClaudeModelCatalog(options = {}) {
+    const execute = options.runClaudeControl ?? runClaudeControl;
+    const request = { type: "control_request", request_id: "larkin-model-list", request: { subtype: "list_models" } };
+    try {
+        return parseCatalog(await execute({ args: ["--safe-mode", "--print", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"],
+            ...(options.command ? { command: options.command } : {}),
+            ...(options.cwd ? { cwd: options.cwd } : {}), env: { ...process.env, ...options.env, NO_COLOR: "1" },
+            maxBuffer: 1024 * 1024, request, timeout: 15_000 }));
+    }
+    catch (error) {
+        if (error instanceof Error && /Claude model catalog/.test(error.message))
+            throw error;
+        throw new Error("Claude model catalog unavailable");
+    }
+}

package/dist/runtime/claude-model-catalog.mjs

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+const SAFE_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._\[\]-]{0,127}$/;
+const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
+function cleanText(value, fallback) {
+    if (typeof value !== "string")
+        return fallback;
+    return value.replace(/[\u0000-\u001f\u007f]+/g, "").replace(/\s+/g, " ").trim().slice(0, 120) || fallback;
+}
+async function runClaudeControl(call) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(call.command || "claude", call.args, { ...(call.cwd ? { cwd: call.cwd } : {}), env: call.env, stdio: ["pipe", "pipe", "pipe"] });
+        let settled = false;
+        let stdout = "";
+        let bytes = 0;
+        const requestId = String(call.request.request_id);
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGTERM");
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error("Claude model catalog timed out")), call.timeout);
+        timer.unref?.();
+        child.on("error", () => finish(new Error("Claude model catalog command failed")));
+        child.on("exit", () => finish(new Error("Claude model catalog control channel exited before response")));
+        child.stderr.resume();
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > call.maxBuffer)
+                return finish(new Error("Claude model catalog response exceeded limit"));
+            stdout += chunk.toString("utf8");
+            for (;;) {
+                const newline = stdout.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = stdout.slice(0, newline);
+                stdout = stdout.slice(newline + 1);
+                try {
+                    const message = JSON.parse(line);
+                    const response = message.response;
+                    if (message.type === "control_response" && response?.request_id === requestId) {
+                        if (response.subtype !== "success")
+                            return finish(new Error("Claude model catalog request failed"));
+                        return finish(undefined, response.response);
+                    }
+                }
+                catch { /* control channel is newline-delimited JSON; ignore unrelated messages */ }
+            }
+        });
+        child.stdin.write(`${JSON.stringify(call.request)}\n`);
+    });
+}
+function efforts(item) {
+    if (item.supportsEffort !== true || !Array.isArray(item.supportedEffortLevels))
+        return [];
+    return [...new Set(item.supportedEffortLevels.filter((level) => typeof level === "string" && EFFORT_LEVELS.has(level)))];
+}
+function parseCatalog(value) {
+    const rows = value?.models;
+    if (!Array.isArray(rows) || rows.length === 0 || rows.length > 128)
+        throw new Error("Claude model catalog has an invalid model list");
+    const defaultRow = rows.find((row) => row?.value === "default");
+    const effectiveModel = typeof defaultRow?.resolvedModel === "string" && SAFE_MODEL_ID.test(defaultRow.resolvedModel) ? defaultRow.resolvedModel : "";
+    const seen = new Set();
+    const models = rows.flatMap((row) => {
+        if (!row || typeof row !== "object" || Array.isArray(row))
+            return [];
+        const item = row;
+        const id = typeof item.value === "string" ? item.value : "";
+        if (id === "default" || !SAFE_MODEL_ID.test(id) || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{ id, label: cleanText(item.displayName, id), supportedReasoningEfforts: efforts(item), verified: "claude-control-visible" }];
+    });
+    if (!effectiveModel || !models.length)
+        throw new Error("Claude model catalog has no visible local default");
+    return { models, effectiveModel, defaultSupportedReasoningEfforts: efforts(defaultRow || {}) };
+}
+export async function discoverClaudeModelCatalog(options = {}) {
+    const execute = options.runClaudeControl ?? runClaudeControl;
+    const request = { type: "control_request", request_id: "larkin-model-list", request: { subtype: "list_models" } };
+    try {
+        return parseCatalog(await execute({ args: ["--safe-mode", "--print", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"],
+            ...(options.command ? { command: options.command } : {}),
+            ...(options.cwd ? { cwd: options.cwd } : {}), env: { ...process.env, ...options.env, NO_COLOR: "1" },
+            maxBuffer: 1024 * 1024, request, timeout: 15_000 }));
+    }
+    catch (error) {
+        if (error instanceof Error && /Claude model catalog/.test(error.message))
+            throw error;
+        throw new Error("Claude model catalog unavailable");
+    }
+}