@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/acp/builds/nodeGate.js

@@ -0,0 +1,100 @@
+/**
+ * The Node gate for npm-built adapters (spec 2026-10-11 §6.2 "Node 门改读已装包的 engines.node").
+ *
+ * A JavaScript adapter declares the Node it needs in its own `package.json#engines.node`; npm/npx never
+ * enforced it, and the old gate matched a hard-coded package name against the spawn args, so any launch
+ * whose args were a path (a patched build, a direct bin launch) went straight past it. The gate is now
+ * a property of the **build** and of **the Node that will run it** (`Build.launch.runtime === 'node'`
+ * runs the entry with the daemon's fixed absolute Node, `AcpAgents`' `nodePath`):
+ *
+ * - at install / migration / certified reconcile ({@link assertBuildRunsOn} from `npmBuild`): an
+ *   unsatisfied range fails the install and the build never becomes current;
+ * - at every launch (`registry/launch.ts` `launchForBuild`): the same check again, because the Node
+ *   that runs a build can change after it was installed (a CLI upgrade bringing its own Node).
+ *
+ * Native entries do not run on Node, so `engines.node` says nothing about them. A range that does not
+ * parse is reported and not enforced — npm itself only warns about one.
+ */
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import semver from 'semver';
+import { inside } from './model.js';
+/** The adapter needs a Node the daemon would not run it with. Carries what the install result reports as `nodeTooOld`. */
+export class AdapterNodeVersionError extends Error {
+    agentId;
+    required;
+    found;
+    constructor(agentId, packageName, version, required, found, nodePath) {
+        super(`Agent '${agentId}' (${packageName} ${version}) needs Node ${required}, but the Node this workstation ` +
+            `runs adapters with (${nodePath}) is ${found}. Upgrade that Node, or install a version of the adapter that supports it.`);
+        this.name = 'AdapterNodeVersionError';
+        this.agentId = agentId;
+        this.required = required;
+        this.found = found;
+    }
+}
+const versions = new Map();
+/**
+ * The version (`v24.1.0`) of the Node at `nodePath`. The daemon's own Node answers from memory; any
+ * other is asked once per process (`<node> --version`) and remembered.
+ */
+export function nodeVersionOf(nodePath) {
+    if (path.resolve(nodePath) === path.resolve(process.execPath))
+        return Promise.resolve(process.version);
+    let known = versions.get(nodePath);
+    if (!known) {
+        known = new Promise((resolve, reject) => {
+            execFile(nodePath, ['--version'], { timeout: 10_000, windowsHide: true }, (error, stdout) => {
+                const version = stdout?.toString().trim() ?? '';
+                if (error || !semver.valid(version)) {
+                    reject(new Error(`Cannot tell the version of the Node adapters run with (${nodePath}): ${error?.message ?? (version || 'no output')}`));
+                    return;
+                }
+                resolve(version);
+            });
+        });
+        // A failed probe is not remembered: the next launch asks again.
+        known.catch(() => versions.delete(nodePath));
+        versions.set(nodePath, known);
+    }
+    return known;
+}
+/** `engines.node` of the package installed at `packageDir`, when it declares one. */
+export async function enginesNodeOf(packageDir) {
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(path.join(packageDir, 'package.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const range = manifest.engines?.node;
+    return typeof range === 'string' && range.trim() ? range.trim() : undefined;
+}
+/** Whether `nodeVersion` satisfies `range`; `undefined` when the range does not parse (not enforced). */
+export function nodeSatisfies(nodeVersion, range) {
+    if (semver.validRange(range) === null)
+        return undefined;
+    return semver.satisfies(nodeVersion, range, { includePrerelease: true });
+}
+/**
+ * Throws {@link AdapterNodeVersionError} when `build` is a JavaScript npm build whose package's
+ * `engines.node` the Node at `nodePath` does not satisfy. Anything else passes.
+ */
+export async function assertBuildRunsOn(build, root, nodePath) {
+    if (build.launch.runtime !== 'node' || !build.package || (build.kind !== 'npm' && build.kind !== 'npm-patched'))
+        return;
+    const packageDir = inside(inside(root, build.dir), `node_modules/${build.package}`);
+    const range = await enginesNodeOf(packageDir);
+    if (range === undefined)
+        return;
+    const found = await nodeVersionOf(nodePath);
+    const satisfied = nodeSatisfies(found, range);
+    if (satisfied === undefined) {
+        console.warn(`[acp-builds] ${build.package} ${build.version} declares engines.node '${range}', which is not a valid range; not enforced.`);
+        return;
+    }
+    if (!satisfied)
+        throw new AdapterNodeVersionError(build.agentId, build.package, build.version, range, found, nodePath);
+}

package/dist/workstation/acp/builds/store.js

@@ -0,0 +1,352 @@
+/**
+ * `builds.json` and the per-agent serialisation of install / switch / GC (spec §6.1–§6.3).
+ *
+ * ## Single writer
+ *
+ * Exactly one daemon owns a config directory, and this store is its only writer of `builds.json`.
+ * Every write is a read-modify-write of the whole document under one in-process mutex, then a
+ * temp-file + `rename(2)`: a reader (or a crash) sees the old document or the new one, never a torn
+ * one.
+ *
+ * ## Per-agent lock
+ *
+ * {@link BuildStore.withAgentLock} serialises everything that creates, selects or (later) collects an
+ * agent's builds. Two concurrent Updates of the same agent therefore run one after the other, and the
+ * second finds the first one's complete tree and downloads nothing. Different agents never wait on
+ * each other — only on the few milliseconds of the document write.
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, open, readdir, readFile, rename, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { BUILDS_FILE, STAGING_DIR, TRASH_DIR, inside } from './model.js';
+/** A FIFO async mutex per key. */
+export class KeyedMutex {
+    tails = new Map();
+    async run(key, work) {
+        const previous = this.tails.get(key) ?? Promise.resolve();
+        let release;
+        const mine = new Promise((resolve) => { release = resolve; });
+        const tail = previous.then(() => mine);
+        this.tails.set(key, tail);
+        await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.tails.get(key) === tail)
+                this.tails.delete(key);
+        }
+    }
+}
+/** Staging trees older than this are leftovers of a killed install and may be swept. */
+const STALE_STAGING_MS = 60 * 60_000;
+function emptyDocument() {
+    return { schema: 1, agents: {} };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export class BuildStore {
+    /** The `acp-adapters` root. */
+    root;
+    agentLocks = new KeyedMutex();
+    documentLock = new KeyedMutex();
+    treeLocks = new KeyedMutex();
+    swept = false;
+    constructor(root) {
+        this.root = root;
+    }
+    get file() {
+        return path.join(this.root, BUILDS_FILE);
+    }
+    /** Serialise install / switch / GC for one agent. Not re-entrant. */
+    withAgentLock(agentId, work) {
+        return this.agentLocks.run(agentId, work);
+    }
+    /**
+     * Serialise everything that creates or deletes one tree that is not published by `rename(2)` (a uv
+     * build, see `model.ts`), keyed by its relative directory. Two agents could share a package; the
+     * agent lock alone would not keep them apart. Taken inside an agent lock, never the other way round.
+     */
+    withTreeLock(dir, work) {
+        return this.treeLocks.run(dir, work);
+    }
+    /** The whole document. A missing file is an empty document; an unreadable one is reported and treated as empty. */
+    async read() {
+        return (await this.readChecked()).document;
+    }
+    /** {@link read}, also saying whether a file was there but unreadable (`commit` must not overwrite it blindly). */
+    async readChecked() {
+        let text;
+        try {
+            text = await readFile(this.file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { document: emptyDocument(), unreadable: false };
+            throw error;
+        }
+        try {
+            const parsed = JSON.parse(text);
+            if (!isRecord(parsed) || parsed.schema !== 1 || !isRecord(parsed.agents))
+                throw new Error('unexpected shape');
+            return { document: parsed, unreadable: false };
+        }
+        catch (error) {
+            console.warn(`[acp-builds] ${this.file} is unreadable (${String(error)}); treating every adapter as not installed.`);
+            return { document: emptyDocument(), unreadable: true };
+        }
+    }
+    async agent(agentId) {
+        return (await this.read()).agents[agentId];
+    }
+    /**
+     * The agent's current build, when one is recorded **and** its directory is still on disk. A record
+     * whose tree was removed behind our back is not an installed adapter.
+     */
+    async current(agentId) {
+        return this.currentIn(await this.read(), agentId);
+    }
+    currentIn(document, agentId) {
+        const entry = document.agents[agentId];
+        const build = entry?.current ? entry.builds?.[entry.current] : undefined;
+        if (!build)
+            return undefined;
+        try {
+            if (!existsSync(inside(this.root, build.dir)))
+                return undefined;
+        }
+        catch {
+            return undefined;
+        }
+        return build;
+    }
+    /**
+     * Record `build` for its agent and, with `makeCurrent`, point `current` at it. The caller holds the
+     * agent's lock and has already renamed the build's tree into place.
+     */
+    async commit(build, options) {
+        await this.documentLock.run('document', async () => {
+            const { document, unreadable } = await this.readChecked();
+            if (unreadable) {
+                // The next write starts from an empty document and would drop every other agent's records for
+                // good. Keep the unreadable file beside it, for a person (or a later repair) to recover them from.
+                const backup = `${this.file}.corrupt-${(options.now ?? new Date()).toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+                await rename(this.file, backup);
+                console.warn(`[acp-builds] moved the unreadable ${this.file} aside to ${backup} before rewriting it.`);
+            }
+            const previous = document.agents[build.agentId];
+            const entry = { ...(previous ?? {}), builds: { ...(previous?.builds ?? {}), [build.buildId]: build } };
+            if (options.makeCurrent) {
+                // The build the pointer leaves is the agent's rollback build (GC keeps one, Task 24).
+                if (previous?.current !== undefined && previous.current !== build.buildId)
+                    entry.previous = previous.current;
+                entry.current = build.buildId;
+                entry.currentSetBy = options.setBy;
+                entry.currentSetAt = (options.now ?? new Date()).toISOString();
+            }
+            document.agents = { ...document.agents, [build.agentId]: entry };
+            await this.write(document);
+        });
+    }
+    /**
+     * A read-modify-write of the whole document under the document lock (Task 24: switch intents, GC). `change` mutates the document
+     * it is given and returns `false` when nothing changed (no write). An unreadable file is never overwritten from here: the change
+     * is refused (`false`) — only {@link commit} (an install) may set an unreadable document aside.
+     */
+    async update(change) {
+        return this.documentLock.run('document', async () => {
+            const { document, unreadable } = await this.readChecked();
+            if (unreadable)
+                return false;
+            if (!change(document))
+                return false;
+            await this.write(document);
+            return true;
+        });
+    }
+    /** Every persistent switch intent (spec §6.3 step 7), by agent and session ref. */
+    async switchIntents() {
+        const document = await this.read();
+        return Object.entries(document.agents).flatMap(([agentId, entry]) => Object.entries(isRecord(entry?.switchPending) ? entry.switchPending : {}).map(([sessionRef, intent]) => ({ agentId, sessionRef, intent })));
+    }
+    /** Records (or replaces) the switch intent of `sessionRef` under `agentId`; one intent per ref (any other agent's is dropped). */
+    setSwitchIntent(agentId, sessionRef, intent) {
+        return this.update((document) => {
+            for (const [other, entry] of Object.entries(document.agents)) {
+                if (other !== agentId && entry.switchPending && Object.hasOwn(entry.switchPending, sessionRef)) {
+                    const { [sessionRef]: _gone, ...rest } = entry.switchPending;
+                    entry.switchPending = rest;
+                }
+            }
+            const entry = document.agents[agentId] ?? { builds: {} };
+            entry.switchPending = { ...(entry.switchPending ?? {}), [sessionRef]: intent };
+            document.agents = { ...document.agents, [agentId]: entry };
+            return true;
+        });
+    }
+    /** Drops the switch intents of `sessionRef` (every agent), or of every ref of `agentId`; `true` when one existed. */
+    cancelSwitchIntents(target) {
+        return this.update((document) => {
+            let changed = false;
+            for (const [agentId, entry] of Object.entries(document.agents)) {
+                if (!entry.switchPending)
+                    continue;
+                if ('agentId' in target) {
+                    if (agentId !== target.agentId || Object.keys(entry.switchPending).length === 0)
+                        continue;
+                    entry.switchPending = {};
+                    changed = true;
+                }
+                else if (Object.hasOwn(entry.switchPending, target.sessionRef)) {
+                    const { [target.sessionRef]: _gone, ...rest } = entry.switchPending;
+                    entry.switchPending = rest;
+                    changed = true;
+                }
+            }
+            return changed;
+        });
+    }
+    /** Removes build records of `agentId` (GC, Task 24). Never the current one. Returns the records removed. */
+    async removeBuilds(agentId, buildIds) {
+        const removed = [];
+        await this.update((document) => {
+            const entry = document.agents[agentId];
+            if (!entry)
+                return false;
+            const builds = { ...entry.builds };
+            for (const buildId of buildIds) {
+                if (buildId === entry.current || !Object.hasOwn(builds, buildId))
+                    continue;
+                removed.push(builds[buildId]);
+                delete builds[buildId];
+            }
+            if (removed.length === 0)
+                return false;
+            entry.builds = builds;
+            if (entry.previous !== undefined && !Object.hasOwn(builds, entry.previous))
+                delete entry.previous;
+            return true;
+        });
+        return removed;
+    }
+    async write(document) {
+        await mkdir(this.root, { recursive: true });
+        await writeFileDurably(this.file, `${JSON.stringify(document, null, 2)}\n`);
+    }
+    /**
+     * A fresh, empty staging directory on the same filesystem as every final location, so the publishing
+     * `rename(2)` is atomic. The first call in a process also sweeps staging trees an earlier, killed
+     * install left behind (only ones older than an hour, so a concurrent install is never touched).
+     */
+    async stagingDir() {
+        const staging = path.join(this.root, STAGING_DIR);
+        await mkdir(staging, { recursive: true });
+        if (!this.swept) {
+            this.swept = true;
+            await sweepOlderThan(staging, STALE_STAGING_MS);
+            // `.trash/` only ever holds trees already renamed out of use; a discard killed before its `rm`
+            // leaves one behind. Nothing is in flight there at first use, so all of it goes.
+            await sweepOlderThan(path.join(this.root, TRASH_DIR), -Infinity);
+        }
+        const directory = path.join(staging, randomUUID());
+        await mkdir(directory);
+        return directory;
+    }
+    /** Move `directory` to `.trash/` and delete it there, so nothing ever observes a half-deleted tree in place. */
+    async discard(directory) {
+        const trash = path.join(this.root, TRASH_DIR);
+        await mkdir(trash, { recursive: true });
+        const target = path.join(trash, randomUUID());
+        try {
+            await rename(directory, target);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        await rm(target, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+/**
+ * Replace `file` with `content` so that a crash at any point leaves the old file or the new one, and a
+ * power loss after return keeps the new one: write a temp file, fsync it, rename it over `file`, then
+ * fsync the directory (where the platform lets a directory be opened — not Windows).
+ */
+export async function writeFileDurably(file, content) {
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        const handle = await open(temporary, 'wx');
+        try {
+            await handle.writeFile(content, 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await syncDirectory(path.dirname(file));
+        await rename(temporary, file);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    await syncDirectory(path.dirname(file));
+}
+async function syncDirectory(directory) {
+    if (process.platform === 'win32')
+        return;
+    let handle;
+    try {
+        handle = await open(directory, 'r');
+    }
+    catch {
+        return;
+    }
+    try {
+        await handle.sync();
+    }
+    catch { /* not supported on this filesystem */ }
+    finally {
+        await handle.close();
+    }
+}
+async function sweepOlderThan(directory, ageMs) {
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return;
+    }
+    const cutoff = Date.now() - ageMs;
+    await Promise.all(names.map(async (name) => {
+        const target = path.join(directory, name);
+        try {
+            if ((await stat(target)).mtimeMs < cutoff)
+                await rm(target, { recursive: true, force: true });
+        }
+        catch { /* already gone */ }
+    }));
+}
+/**
+ * Publish a complete `staged` tree at `final` with one `rename(2)`. When another install already
+ * published the same immutable tree (`EEXIST`/`ENOTEMPTY`), the staged copy is dropped and the
+ * existing one is used: `published: false`.
+ */
+export async function publishStaged(staged, final) {
+    await mkdir(path.dirname(final), { recursive: true });
+    try {
+        await rename(staged, final);
+        return { published: true };
+    }
+    catch (error) {
+        if (!['EEXIST', 'ENOTEMPTY'].includes(error.code ?? ''))
+            throw error;
+        await rm(staged, { recursive: true, force: true }).catch(() => undefined);
+        return { published: false };
+    }
+}

package/dist/workstation/acp/commandTableProbe.js

@@ -0,0 +1,68 @@
+import { methods } from '@agentclientprotocol/sdk';
+import { newSessionMetaFor } from './activityReporting.js';
+import { normalizeConfigOptions } from './configOptions.js';
+/** Updates kept for a session id this client has not yet learned (the pre-bind window). */
+const EARLY_UPDATES_MAX = 32;
+export function createCommandTableProbe() {
+    const early = [];
+    let target;
+    let onTable;
+    return {
+        configure(app) {
+            app.onNotification(methods.client.session.update, (ctx) => {
+                const update = ctx.params.update;
+                if (update.sessionUpdate !== 'available_commands_update')
+                    return;
+                if (target === undefined) {
+                    if (early.length >= EARLY_UPDATES_MAX)
+                        early.shift();
+                    early.push({ sessionId: ctx.params.sessionId, commands: update.availableCommands });
+                }
+                else if (ctx.params.sessionId === target) {
+                    onTable?.(update.availableCommands);
+                }
+            });
+        },
+        async observe(connection, cwd, timing) {
+            const meta = newSessionMetaFor(connection.agentInfo?.name);
+            const response = await connection.connection.agent.request(methods.agent.session.new, {
+                cwd, mcpServers: [], ...(meta ? { _meta: meta } : {}),
+            });
+            const configOptions = normalizeConfigOptions(response.configOptions, response.modes, response.models);
+            let raw;
+            let finish;
+            const settled = new Promise((resolve) => { finish = resolve; });
+            let quietTimer;
+            let ceilingTimer;
+            let firstTimer = setTimeout(() => finish?.(), timing.firstWindowMs);
+            const table = (commands) => {
+                if (Array.isArray(commands))
+                    raw = commands;
+                // The first one: the first-table window is over; settle on quiet, under the ceiling.
+                if (firstTimer !== undefined) {
+                    clearTimeout(firstTimer);
+                    firstTimer = undefined;
+                    ceilingTimer = setTimeout(() => finish?.(), timing.ceilingMs);
+                }
+                // Every further one restarts the quiet period (Claude's second table is the usable one).
+                if (quietTimer !== undefined)
+                    clearTimeout(quietTimer);
+                quietTimer = setTimeout(() => finish?.(), timing.quietMs);
+            };
+            target = response.sessionId;
+            onTable = table;
+            for (const update of early.splice(0))
+                if (update.sessionId === target)
+                    table(update.commands);
+            await settled;
+            if (firstTimer !== undefined)
+                clearTimeout(firstTimer);
+            if (quietTimer !== undefined)
+                clearTimeout(quietTimer);
+            if (ceilingTimer !== undefined)
+                clearTimeout(ceilingTimer);
+            onTable = undefined;
+            return { raw, configOptions };
+        },
+    };
+}

package/dist/workstation/acp/configOptions.js

@@ -4,6 +4,15 @@
  * 就用这个 id 的情形（agent 的赢，什么都不合成）。
  */
 export const SYNTHESIZED_MODES_CONFIG_ID = 'acp:modes';
+/**
+ * daemon 保留 id：agent 只给 unstable 的 `models`（`SessionModelState`——hermes，以及不经自己的
+ * configOption 暴露模型的 agent）而没有自己的模型控件时合成。与 {@link SYNTHESIZED_MODES_CONFIG_ID}
+ * 同一条规则：agent 自己的控件赢（`id: "model"` 或 `category: "model"`，pi-acp 的
+ * `buildConfigOptions` 两者都用），合成只在缺席时补位。合成的是**分组** select（组 = provider，
+ * {@link modelGroupsOf}），页脚选择器据此按 provider 分层展示；设置它的值经 `processor/control.ts`
+ * 路由到 ACP 的 `session/set_model`，不走 `session/set_config_option`。
+ */
+export const SYNTHESIZED_MODEL_CONFIG_ID = 'acp:model';
 function toSelectOption(o) {
     return { value: o.value, name: o.name, ...(o.description != null ? { description: o.description } : {}) };
 }
@@ -122,6 +131,88 @@ function toWire(option) {
     }
     return null;
 }
+/**
+ * One raw `SessionModelState` (`models` in a `session/new|load|fork|resume` result; hermes sends it
+ * unconditionally), sanitized — `null` when it isn't a record, `currentModelId` isn't a string,
+ * `availableModels` isn't an array, or nothing usable is left after entry-by-entry sanitizing.
+ * The same read-nothing-off-null boundary as {@link sanitizeModes}; the TS SDK's v1 schema does not
+ * model this unstable field at all, so this is the only validation it ever gets.
+ */
+function sanitizeModels(models) {
+    if (!isRecord(models) || typeof models.currentModelId !== 'string' || !Array.isArray(models.availableModels))
+        return null;
+    const availableModels = [];
+    for (const entry of models.availableModels) {
+        if (!isRecord(entry))
+            continue;
+        if (typeof entry.modelId !== 'string' || entry.modelId === '' || typeof entry.name !== 'string')
+            continue;
+        if (entry.description != null && typeof entry.description !== 'string')
+            continue;
+        availableModels.push({ modelId: entry.modelId, name: entry.name, description: entry.description });
+    }
+    if (availableModels.length === 0)
+        return null;
+    return { currentModelId: models.currentModelId, availableModels };
+}
+/**
+ * `modelId` 的 provider 段：`anthropic:claude-opus-4.6` → `anthropic`；没有 `:` 的 id 没有可提取的
+ * provider，返回 `''` —— 它们全部落进同一个桶，而不是各成一组（每个组里只有一个没有 provider 的模型）。
+ */
+function providerKeyOf(modelId) {
+    const colon = modelId.indexOf(':');
+    return colon > 0 ? modelId.slice(0, colon) : '';
+}
+/** hermes 的描述字段写着 `Provider: Anthropic`——组名优先从那里取；取不到时，无 provider 桶叫
+ * `Models`，其余退回 provider key 原样。 */
+function providerNameOf(key, group) {
+    for (const model of group) {
+        const match = /^Provider:\s*(.+)$/.exec((model.description ?? '').trim());
+        if (match)
+            return match[1];
+    }
+    return key === '' ? 'Models' : key;
+}
+/**
+ * `availableModels` → 分组 options（`SessionConfigSelectGroup`）。组 = `modelId` 的 provider 段，
+ * 遇到序保持（agent 自己的目录顺序就是它的推荐顺序）；组内每一条的名字如果都以
+ * `<组名> · ` 开头（hermes：`Anthropic · claude-opus-4.6`），把这段前缀去掉——组标题已经说了它是谁。
+ */
+export function modelGroupsOf(availableModels) {
+    const byKey = new Map();
+    for (const model of availableModels) {
+        const key = providerKeyOf(model.modelId);
+        const bucket = byKey.get(key);
+        if (bucket)
+            bucket.push(model);
+        else
+            byKey.set(key, [model]);
+    }
+    return [...byKey.entries()].map(([key, group]) => {
+        const groupName = providerNameOf(key, group);
+        const prefix = `${groupName} · `;
+        const strip = group.length > 1 && group.every((model) => model.name.startsWith(prefix));
+        return {
+            group: key,
+            name: groupName,
+            options: group.map((model) => ({
+                value: model.modelId,
+                name: strip ? model.name.slice(prefix.length) : model.name,
+                ...(model.description != null ? { description: model.description } : {}),
+            })),
+        };
+    });
+}
+/**
+ * "This list already gives the reader a control for models" — `id: "model"`（pi-acp 的
+ * `MODEL_CONFIG_ID`）、`category: "model"`（ACP 给模型控件的归类，pi-acp 两者都用），或 agent 自己
+ * 占了保留 id。与 {@link modesAlreadyRepresented} 同一条规则：agent 自己的赢，合成的退位。不比较
+ * 选项列表：modes 那边的逐条比对是因为 pi 真的把同一份清单发了两遍，而模型控件的 `category`
+ * 归类是 ACP 明文写的、pi-acp 也遭守，靠它就够。
+ */
+export function modelsAlreadyRepresented(options) {
+    return options.some((o) => o.id === 'model' || o.id === SYNTHESIZED_MODEL_CONFIG_ID || o.category === 'model');
+}
 /**
  * One raw `SessionMode` entry (`types.gen.d.ts:2590-2613`), sanitized — `null` when it isn't a
  * record, or `id`/`name` are missing or not strings, or a `description` is present but not a
@@ -236,7 +327,7 @@ export function modesAlreadyRepresented(options, choices) {
  * Nothing below this function re-derives either guarantee — that is the point of establishing it
  * once, here.
  */
-export function normalizeConfigOptions(configOptions, modes) {
+export function normalizeConfigOptions(configOptions, modes, models) {
     const rawOptions = Array.isArray(configOptions) ? configOptions.filter(isRecord) : [];
     const out = rawOptions.map(toWire).filter((o) => o !== null);
     const cleanModes = sanitizeModes(modes);
@@ -253,5 +344,16 @@ export function normalizeConfigOptions(configOptions, modes) {
             });
         }
     }
+    const cleanModels = sanitizeModels(models);
+    if (cleanModels && !modelsAlreadyRepresented(out)) {
+        out.push({
+            id: SYNTHESIZED_MODEL_CONFIG_ID,
+            name: 'Model',
+            category: 'model',
+            type: 'select',
+            currentValue: cleanModels.currentModelId,
+            options: modelGroupsOf(cleanModels.availableModels),
+        });
+    }
     return out;
 }

package/dist/workstation/acp/delegationMcp.js

@@ -0,0 +1,24 @@
+export function buildSessionMcpServers(userServers = [], lease) {
+    if (!lease)
+        return [...userServers];
+    const fail = () => { throw new Error('Delegation MCP configuration is unavailable'); };
+    let url;
+    try {
+        url = new URL(lease.url);
+    }
+    catch {
+        return fail();
+    }
+    if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash ||
+        url.pathname !== '/mcp/delegation' || !Number.isSafeInteger(lease.expiresAtEpochMs) ||
+        lease.expiresAtEpochMs <= Date.now() || userServers.some((server) => server.name === 'axom-delegation'))
+        return fail();
+    const headers = Object.entries(lease.headers);
+    if (headers.length !== 1 || headers[0][0].toLowerCase() !== 'authorization' ||
+        !/^Bearer [A-Za-z0-9_-]+$/.test(headers[0][1]))
+        return fail();
+    return [...userServers, {
+            type: 'http', name: 'axom-delegation', url: url.toString(),
+            headers: headers.map(([name, value]) => ({ name, value })),
+        }];
+}