@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/acp/contract.js

@@ -1,499 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AgentSpawnError } from './acpClient.js';
-import { AGENT_FRAME_SHAPES, decodeAgentFrame, encodeAgentFrame } from '../protocol/agent.js';
-import { validateWireEvent } from './validate.js';
-/**
- * Default wait for output, deliberately under vitest's 5s default test timeout: whichever fires
- * first writes the failure message, and "timed out waiting for <what>" is far more useful than
- * vitest's generic test timeout.
- */
-export const DEFAULT_CONTRACT_TIMEOUT_MS = 4_000;
-/** Multiplier on the measured turn duration used as the quiet window in the buffering check. */
-const BUFFERING_QUIET_FACTOR = 3;
-/** Floor for that window, so a synchronous sample (turn duration ≈ 0) still gets a real one. */
-const BUFFERING_QUIET_FLOOR_MS = 25;
-const TURN_STOP_REASONS = new Set([
-    'end_turn', 'max_tokens', 'max_turns', 'refusal', 'interrupted', 'superseded', 'expired', 'orphaned',
-]);
-function turnResultViolation(result) {
-    if (!['completed', 'interrupted', 'failed'].includes(result.status)) {
-        return `turn result has invalid status '${String(result.status)}'`;
-    }
-    if (result.stopReason !== undefined && !TURN_STOP_REASONS.has(result.stopReason)) {
-        return `turn result has invalid stopReason '${String(result.stopReason)}'`;
-    }
-    return null;
-}
-/** Registers both sinks the way `agentSessions.ts` does: `onEvent` first, then `onTurnDone`. */
-function record(session) {
-    const events = [];
-    const turns = [];
-    session.onEvent((e) => events.push(e));
-    session.onTurnDone((r) => turns.push(r));
-    return { events, turns };
-}
-function timeoutOf(hooks) {
-    return hooks.timeoutMs ?? DEFAULT_CONTRACT_TIMEOUT_MS;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitFor(hooks, what, predicate) {
-    const deadline = Date.now() + timeoutOf(hooks);
-    while (!predicate()) {
-        if (Date.now() >= deadline)
-            throw new Error(`timed out waiting for ${what}`);
-        await sleep(5);
-    }
-}
-/**
- * Opens a session, runs the body, and always disposes.
- *
- * `session.close()` is not called here: it is clause 6's own subject, and a session that cannot
- * close should fail that check alone rather than smear an error across every other one. `dispose()`
- * is what actually reclaims the subprocess, and its failures are swallowed for the same reason.
- */
-async function withSession(hooks, open, body) {
-    const target = await open();
-    try {
-        await body(target.session);
-    }
-    finally {
-        try {
-            await target.dispose();
-        }
-        catch {
-            // teardown is not any clause's subject
-        }
-    }
-}
-function requireHook(hooks, name) {
-    const hook = hooks[name];
-    // Only reachable if a caller invoked a gated check directly, or the skip branch in
-    // runAcpContract was removed. Throwing keeps that from reading as a pass.
-    if (!hook)
-        throw new Error(`the '${name}' hook is required for this check`);
-    return hook;
-}
-function isPermissionCard(e) {
-    return e.eventName === 'permission_request';
-}
-/** Names an event for a failure message without trusting it to be well-formed. */
-function nameOf(e) {
-    try {
-        return String(e?.eventName);
-    }
-    catch {
-        return '<uninspectable>';
-    }
-}
-function describeRejection(what, e) {
-    const rejection = validateWireEvent(e);
-    if (!rejection)
-        return null;
-    return `${what} '${nameOf(e)}' violates the wire contract: ${rejection.reason}${rejection.detail ? ` (${rejection.detail})` : ''}`;
-}
-// --- the checks ---------------------------------------------------------------------------------
-/**
- * Every clause, in the deleted kit's own order so the two can be read side by side.
- *
- * Two of that kit's ten checks are gone, and one is here with a different assertion:
- *
- * - `probe-total` (clause 1, "`probe()` reports availability instead of throwing", plus
- *   `AgentBridge.type` being a non-empty string) is **dropped**. Neither subject exists: ACP has no
- *   `probe`, and an agent's identity is now a registry id the client is handed rather than a string
- *   a bridge declares about itself. More than that, `AcpAgents.verify` deliberately *does* throw
- *   when the agent cannot be launched — the clause is not merely unimplemented, it is inverted on
- *   purpose (see `acpAgents.ts`'s "Two outcomes, and neither of them is 'not authenticated'").
- * - `probe-reports-unavailable` (clause 1) survives as {@link unavailableAgentIsDiagnosable}, with a
- *   **new assertion**. The clause it encoded — an absent binary must stay distinguishable from a
- *   transient failure, because nothing above this layer can tell them apart — still holds exactly.
- *   The mechanism inverted: `{available: false}` became a typed `AgentSpawnError`, and it is that
- *   typing, not a boolean, that keeps "not installed" from collapsing into a generic failure.
- */
-export const acpContractChecks = [
-    {
-        id: 'unavailable-agent-is-diagnosable',
-        clause: 1,
-        title: 'an agent that is not installed fails with a typed, actionable error',
-        requires: 'connectUnavailableAgent',
-        run: async (hooks) => {
-            const connect = requireHook(hooks, 'connectUnavailableAgent');
-            let outcome;
-            try {
-                outcome = { ok: true, value: await connect() };
-            }
-            catch (error) {
-                outcome = { ok: false, error };
-            }
-            // Resolving is the failure mode this catches, and it is the subtle one: a client that reports
-            // a missing agent as connected sends every later failure to the wrong layer, and the user gets
-            // "did not open a session" for an agent that was never on the machine.
-            expect(outcome.ok, 'connecting to an agent that is not installed must fail, not resolve').toBe(false);
-            const error = outcome.error;
-            // Typed, not merely thrown. `AcpAgents.verify` catches around `AcpSession.open` and turns
-            // failures into an inconclusive `sessionError`; only the launch failure being its own class
-            // keeps "not installed" from being answered as "installed, but something went wrong".
-            expect(error instanceof AgentSpawnError, `a not-installed agent must reject with AgentSpawnError, got ${error instanceof Error ? error.constructor.name : typeof error}: ${String(error)}`).toBe(true);
-            expect(String(error.message).length, 'the rejection must carry a message a user can act on').toBeGreaterThan(0);
-        },
-    },
-    {
-        id: 'pre-registration-buffering',
-        clause: 2,
-        title: 'events produced before onEvent/onTurnDone are buffered and flushed on registration',
-        requires: null,
-        run: async (hooks) => {
-            // `agentSessions.ts` registers its sinks immediately *after* the session resolves, so anything
-            // produced during or right after open lands with no callback attached.
-            //
-            // Driving-then-registering is not on its own enough to prove buffering: `driveOneTurn`
-            // resolves long before the agent says anything, so registration wins the race and the events
-            // arrive live. The check would then pass for a client that buffers nothing at all.
-            //
-            // So: measure how long a turn takes when observed live, then drive a second turn with no sink
-            // attached and wait past that duration before registering. By then the turn is over. Anything
-            // that still arrives was held; an implementation that drops has nothing left to deliver and
-            // times out.
-            let turnMs = 0;
-            await withSession(hooks, hooks.openSession, async (session) => {
-                const seen = record(session);
-                const started = Date.now();
-                await hooks.driveOneTurn(session);
-                await waitFor(hooks, 'a baseline turn to produce an event (with the sinks already registered)', () => seen.events.length > 0);
-                await waitFor(hooks, 'a baseline turn to finish (with the sinks already registered)', () => seen.turns.length > 0);
-                turnMs = Date.now() - started;
-            });
-            const quietMs = Math.max(BUFFERING_QUIET_FLOOR_MS, turnMs * BUFFERING_QUIET_FACTOR);
-            if (quietMs > timeoutOf(hooks)) {
-                // Deliberately loud rather than clamped to the timeout. Clamping still "works" — the
-                // baseline finished inside timeoutMs, so the window would stay longer than a turn — but it
-                // shrinks the margin towards 1x precisely when turns are slow, and says nothing while doing
-                // it. That is a silent degradation of the check itself, which is what this refuses.
-                throw new Error(`a baseline turn took ${turnMs}ms, so this check needs a ${quietMs}ms quiet window, but ` +
-                    `timeoutMs is ${timeoutOf(hooks)}ms. Raise timeoutMs above ${quietMs} (and vitest's own ` +
-                    `testTimeout past it) so the buffering check has a real window rather than one barely ` +
-                    `longer than a turn.`);
-            }
-            const dropped = (what) => `${what} to be flushed on registration — the turn was driven and left to run for ${quietMs}ms ` +
-                `(a live turn took ${turnMs}ms) with no sink attached, so an implementation that drops instead ` +
-                `of buffering has already discarded it`;
-            await withSession(hooks, hooks.openSession, async (session) => {
-                await hooks.driveOneTurn(session);
-                await sleep(quietMs);
-                const seen = record(session);
-                await waitFor(hooks, dropped('events produced before registration'), () => seen.events.length > 0);
-                await waitFor(hooks, dropped('the turn result produced before registration'), () => seen.turns.length > 0);
-            });
-        },
-    },
-    {
-        id: 'events-valid',
-        clause: 3,
-        title: 'every emitted event passes validateWireEvent',
-        requires: null,
-        run: async (hooks) => {
-            await withSession(hooks, hooks.openSession, async (session) => {
-                const seen = record(session);
-                await hooks.driveOneTurn(session);
-                await waitFor(hooks, 'the driven turn to produce at least one event', () => seen.events.length > 0);
-                await waitFor(hooks, 'the driven turn to finish', () => seen.turns.length > 0);
-                for (const e of seen.events) {
-                    // Encoded as a string so the assertion message names the offending event and reason;
-                    // a bare `toBeNull()` on the rejection object reads as "expected {…} to be null".
-                    expect(describeRejection('event', e)).toBeNull();
-                }
-                for (const turn of seen.turns) {
-                    expect(turnResultViolation(turn)).toBeNull();
-                }
-            });
-        },
-    },
-    {
-        id: 'no-unknown-request-events',
-        clause: 3,
-        title: 'no request-shaped event other than permission_request is emitted',
-        requires: null,
-        run: async (hooks) => {
-            // Split out of `events-valid` on purpose, even though validateWireEvent rejects these too:
-            // this is the clause an implementer is most likely to trip while doing something reasonable.
-            // Under ACP the temptation is concrete and sitting in the code already — `permission.ts`
-            // declines every `elicitation/create`, and "just emit an `elicitation_request`" is the
-            // obvious-looking next step. Since Plan B it is *more* tempting, not less: the platform now
-            // owns that event name for its own agents' questions. It is still unanswerable from a bridge —
-            // `TimelineEventWire.decode` has no branch for it, so the server drops the event and advances
-            // its watermark past it, it can never even be replayed, and the agent waits forever. A named
-            // check says that in the failure message instead of leaving it inside a generic one.
-            await withSession(hooks, hooks.openSession, async (session) => {
-                const seen = record(session);
-                await hooks.driveOneTurn(session);
-                await waitFor(hooks, 'the driven turn to produce at least one event', () => seen.events.length > 0);
-                await waitFor(hooks, 'the driven turn to finish', () => seen.turns.length > 0);
-                const offenders = seen.events
-                    .map(nameOf)
-                    .filter((name) => (name.endsWith('_request') || name.endsWith('_requested')) && name !== 'permission_request');
-                expect(offenders, 'only permission_request may carry a request suffix — the platform has no way to answer ' +
-                    'any other request-shaped event, and the server drops it. `_requested` is the retired ' +
-                    'spelling and is caught here too, so an unupgraded bridge fails loudly rather than ' +
-                    'having its approval cards silently land as generic items').toEqual([]);
-            });
-        },
-    },
-    {
-        id: 'permission-card-answerable',
-        clause: 3,
-        title: 'permission_request cards are well-formed and answerable',
-        requires: 'drivePermission',
-        run: async (hooks) => {
-            const drivePermission = requireHook(hooks, 'drivePermission');
-            await withSession(hooks, hooks.openPermissionSession ?? hooks.openSession, async (session) => {
-                const seen = record(session);
-                await drivePermission(session);
-                await waitFor(hooks, 'a permission_request event', () => seen.events.some(isPermissionCard));
-                // An option-less card is the one that hurts: the session parks on a prompt the user has no
-                // button to answer, and Stop becomes the only way out. Under ACP the options are the
-                // *agent's* own (`permission.ts` passes them through rather than inventing a vocabulary), so
-                // this clause is now a statement about what this client refuses to relay.
-                for (const card of seen.events.filter(isPermissionCard)) {
-                    expect(describeRejection('permission card', card)).toBeNull();
-                }
-            });
-        },
-    },
-    {
-        id: 'stale-answer-tolerated',
-        clause: 4,
-        title: 'answer() tolerates an unknown requestId',
-        requires: null,
-        run: async (hooks) => {
-            await withSession(hooks, hooks.openSession, async (session) => {
-                const seen = record(session);
-                // The server synthesizes a deny for the outstanding card when the user sends a plain
-                // message instead of answering it — by then the client may have forgotten the id entirely.
-                expect(() => session.answer('contract-never-issued-request-id', 'deny'), 'answer() with an unknown requestId must not throw').not.toThrow();
-                // …and must not have wedged the session either.
-                await hooks.driveOneTurn(session);
-                await waitFor(hooks, 'the session to keep working after a stale answer', () => seen.turns.length > 0);
-            });
-        },
-    },
-    {
-        id: 'superseded-answer-tolerated',
-        clause: 4,
-        title: 'answer() tolerates a requestId that was already answered',
-        requires: 'drivePermission',
-        run: async (hooks) => {
-            const drivePermission = requireHook(hooks, 'drivePermission');
-            await withSession(hooks, hooks.openPermissionSession ?? hooks.openSession, async (session) => {
-                const seen = record(session);
-                await drivePermission(session);
-                await waitFor(hooks, 'a permission_request event', () => seen.events.some(isPermissionCard));
-                const card = seen.events.find(isPermissionCard);
-                const requestId = String(card?.payload?.requestId ?? '');
-                expect(requestId, 'permission_request must carry a requestId').not.toBe('');
-                const options = Array.isArray(card?.payload?.options) ? card.payload.options : [];
-                const outcome = typeof options[0]?.optionId === 'string' ? String(options[0].optionId) : 'deny';
-                expect(() => session.answer(requestId, outcome), 'answering an outstanding card must not throw').not.toThrow();
-                // The same id a second time: the card is settled and the client has dropped it, but the
-                // server can still send a synthesized deny for it.
-                expect(() => session.answer(requestId, 'deny'), 'answer() for an already-settled requestId must not throw').not.toThrow();
-            });
-        },
-    },
-    {
-        id: 'interrupt-ends-turn',
-        clause: 5,
-        title: "interrupt() ends the turn with status 'interrupted'",
-        // The deleted per-bridge suite's equivalent clause ran unconditionally, against every bridge. It
-        // now runs only when a hook can force a real in-flight turn, and `realAdapterHooks()` (this
-        // file's real-adapter describe block, below) deliberately doesn't provide `openHangingSession` —
-        // see its comment — so against a real ACP adapter this clause's coverage is not reduced, it is
-        // zero (review finding, task-11 fix round 1, finding 3).
-        requires: 'openHangingSession',
-        run: async (hooks) => {
-            const openHanging = requireHook(hooks, 'openHangingSession');
-            await withSession(hooks, openHanging, async (session) => {
-                const seen = record(session);
-                // Driven with prompt() against a session whose turn will not finish on its own: a turn that
-                // already completed cannot be interrupted, so against an ordinary session the check would
-                // prove nothing. The assertion is on the *last* result, so an early 'completed' is a failure
-                // rather than something the check quietly accepts.
-                session.prompt([{ type: 'text', text: 'contract: start a turn that will be interrupted' }]);
-                await session.interrupt();
-                await waitFor(hooks, 'a turn result after interrupt()', () => seen.turns.length > 0);
-                const last = seen.turns[seen.turns.length - 1];
-                expect(last?.status, 'the turn after interrupt() must end as interrupted').toBe('interrupted');
-            });
-        },
-    },
-    {
-        id: 'close-idempotent',
-        clause: 6,
-        title: 'close() is idempotent',
-        requires: null,
-        run: async (hooks) => {
-            const target = await hooks.openSession();
-            try {
-                await target.session.close();
-                // `agentSessions.ts` can close a session a transport drop already tore down; a second close
-                // must be a no-op, not a rejection that surfaces as a spurious daemon error.
-                await target.session.close();
-            }
-            finally {
-                await target.dispose().catch(() => undefined);
-            }
-        },
-    },
-    {
-        id: 'every-prompt-gets-a-turn-result',
-        clause: 7,
-        title: 'two overlapping prompts each report their own terminal turn result',
-        requires: null,
-        run: async (hooks) => {
-            // New in ACP, and pinning a real defect rather than a hypothetical one.
-            //
-            // `AcpSession.prompt`'s own doc comment lists an overlapping call as an expected case, and
-            // ACP itself allows it — the SDK's `ActiveSession.prompt` enqueues a `stop` message per call,
-            // so two prompts really do produce two completions on the read queue. Everything downstream
-            // is built on one result per prompt: each `prompt()` call pushes its own entry onto
-            // `AcpSession.inFlightTurns`, `finishTurn` pops exactly one entry per completion it sees (not
-            // "the" entry, "an" entry — see its own doc), and `agentSessions.ts`'s `onAgentTurnDone`
-            // fires once per `finishTurn` call and emits one `agent_turn_done` frame each time (2026-09-21
-            // rewrite; there is no longer a `tasks.agentTurnStarted`/`agentTurnFinished` bracket in the
-            // middle of that path, but the one-result-per-prompt pairing itself is unchanged — it was
-            // always `inFlightTurns`' push/pop symmetry, not the bracket, that guaranteed it). The
-            // server's run stays parked until a `turn_done` arrives, and `agent_message` — the event that
-            // flushes the server's delta buffer and attaches the turn's usage figures — is synthesized
-            // only as a turn ends. A dropped second result therefore does not merely lose a status line:
-            // it strands the second turn's text and parks the run indefinitely.
-            //
-            // Driven through `driveOneTurn` twice concurrently rather than two bare `prompt()` calls so a
-            // real adapter's hook (which may need to say something specific to get output) is what decides
-            // how a turn is started.
-            await withSession(hooks, hooks.openSession, async (session) => {
-                const seen = record(session);
-                await Promise.all([hooks.driveOneTurn(session), hooks.driveOneTurn(session)]);
-                await waitFor(hooks, 'both overlapping turns to report a terminal result — a second turn whose result never ' +
-                    'arrives leaves the platform parked on a run that has already finished', () => seen.turns.length >= 2);
-                for (const turn of seen.turns) {
-                    expect(turnResultViolation(turn)).toBeNull();
-                }
-            });
-        },
-    },
-];
-/**
- * Which checks {@link runAcpContract} will run and which it will skip, for these hooks.
- *
- * Extracted so "skipped, never silently passed" is assertable. Left inline in the `describe` body,
- * the decision lives only in a branch whose failure mode — a case that runs an empty body and
- * reports green — no assertion can see.
- */
-export function acpContractRunPlan(hooks) {
-    return acpContractChecks.map((check) => ({
-        id: check.id,
-        skipped: check.requires !== null && hooks[check.requires] === undefined,
-    }));
-}
-/**
- * Clause 8 — every field the agent channel treats as required must actually be enforced by the
- * decoder, for every frame type.
- *
- * ### Why this is one general clause rather than an assertion per field
- *
- * Task 10a shipped `agent_authenticate` with no guard on `methodId`. The frame decoded cleanly, and
- * `AcpAuth.authenticate(undefined)` ran all the way to the agent. The follow-up review then
- * enumerated every field of the two new frames by hand and found nothing else — a real answer with
- * a one-release shelf life, because the next frame added gets no such treatment.
- *
- * ### Where "required" comes from, and why it must not come from the guard table
- *
- * The obvious implementation — read the field names off `AGENT_FRAME_SHAPES` and check each one is
- * enforced — is circular, and measurably so: deleting `methodId` from that table leaves such a check
- * green, because the check stops looking for exactly the field the guard stopped guarding. That is
- * the original bug reproduced, not caught.
- *
- * So required-ness is taken from a **second, independent declaration**: the `AgentFrame` union.
- * `samples` is typed as `AgentFrame`, so TypeScript will not accept an entry missing a non-optional
- * field, and the samples are required to carry *only* those fields. A sample's own keys are therefore
- * the union's mandatory field list, arrived at without consulting the guard table at all. This
- * function then asserts the two agree — set equality, so a guard the table forgot and a field a
- * sample invented are both failures — before asserting the decoder actually rejects each one.
- *
- * Hook-free, unlike every clause above, which is why it is its own exported function rather than an
- * entry in {@link acpContractChecks}: it has no session to drive. The samples come from the caller
- * because a valid instance of each frame is test data, not something a type can synthesize.
- */
-export function assertRequiredFieldsEnforced(samples, 
-/**
- * The decoder under test. Defaults to the real one; parameterized only so `contract.test.ts` can
- * hand in a deliberately lenient decoder and assert this function rejects it. Without that, "the
- * clause holds" and "the clause is unfalsifiable" look identical from the outside.
- */
-decode = decodeAgentFrame) {
-    // Coverage first: without this, a frame type with no sample contributes no assertions at all and
-    // the whole clause passes vacuously for it.
-    expect(Object.keys(samples).sort(), 'every agent frame type needs a valid sample here, or its required fields go unchecked').toEqual(Object.keys(AGENT_FRAME_SHAPES).sort());
-    // Every sample is vetted before any of them is mutilated, rather than vetting and mutilating one
-    // frame at a time. Interleaved, a rotten sample late in the map would only be reported *after*
-    // some earlier frame's deletion had already failed for an unrelated reason, and the message a
-    // reader gets would name the wrong frame.
-    const requiredByType = new Map();
-    for (const [type, sample] of Object.entries(samples)) {
-        expect(sample.t, `the sample filed under '${type}' must be a ${type} frame`).toBe(type);
-        // The sample itself has to decode, or every deletion below "fails" for the wrong reason and the
-        // clause would pass while proving nothing.
-        expect(() => decode(encodeAgentFrame(sample)), `the sample ${type} frame must itself decode`).not.toThrow();
-        // The union's mandatory fields, read off an instance the type checker vouched for. `t` is the
-        // discriminator rather than a payload field, and `decodeChannelFrame` rejects an unknown one
-        // before any guard runs, so it is not this clause's subject.
-        const fromUnion = Object.keys(sample).filter((key) => key !== 't').sort();
-        expect(fromUnion.length, `the sample ${type} frame carries no fields, so it checks nothing`).toBeGreaterThan(0);
-        expect(
-        // Cast, not a narrowed lookup: `type` is `samples`'s own `string` key, but the coverage
-        // assertion just above (line 608-610) already proved it is one of `AGENT_FRAME_SHAPES`'s keys
-        // before this loop ever runs.
-        Object.keys(AGENT_FRAME_SHAPES[type].required).sort(), `${type}'s guard table and its AgentFrame union member disagree about which fields are ` +
-            'required. Either the table is missing a guard for a field the type says is mandatory ' +
-            '(the shape `agent_authenticate.methodId` shipped in), or this sample carries an optional ' +
-            'field it should not — samples here must carry required fields and nothing else').toEqual(fromUnion);
-        requiredByType.set(type, fromUnion);
-    }
-    for (const [type, sample] of Object.entries(samples)) {
-        for (const field of requiredByType.get(type)) {
-            const mutilated = { ...sample };
-            delete mutilated[field];
-            expect(() => decode(JSON.stringify(mutilated)), `${type} must be rejected when required field '${field}' is missing — the Kotlin twin cannot ` +
-                'decode it, and a frame that passes here and fails there is a silent drop on the far side').toThrow();
-        }
-    }
-}
-/**
- * Run the whole contract suite. Call at the top level of a test file:
- *
- * ```ts
- * runAcpContract('ACP client over the in-repo fake agent', { openSession: …, driveOneTurn: … });
- * ```
- *
- * Cases needing an optional hook are skipped — visibly, as skipped — when it is absent.
- */
-export function runAcpContract(name, hooks) {
-    const plan = new Map(acpContractRunPlan(hooks).map((entry) => [entry.id, entry.skipped]));
-    describe(name, () => {
-        for (const check of acpContractChecks) {
-            const label = `clause ${check.clause}: ${check.title}`;
-            if (plan.get(check.id)) {
-                // The real body, not an empty one. Never executed while skipped — but the instant `.skip`
-                // comes off, the check runs, hits its missing hook and goes red. An empty body would go
-                // green and leave the run plan still reporting it as skipped, so nothing would notice.
-                it.skip(label, async () => {
-                    await check.run(hooks);
-                }, hooks.vitestTimeoutMs);
-                continue;
-            }
-            it(label, async () => {
-                await check.run(hooks);
-            }, hooks.vitestTimeoutMs);
-        }
-    });
-}

package/dist/workstation/acp/delegationMcp.js

@@ -1,24 +0,0 @@
-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 })),
-        }];
-}