@north-light/crouter 0.3.173 → 0.3.175

package/dist/core/user-settings.js

@@ -57,6 +57,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
                 description: 'Notify about crouter releases, install them automatically, or turn checks off.',
                 valueConstraint: 'true|false|notify|apply; true stores notify',
                 applies: 'Applies on the next crouter command.',
+                group: 'updates',
                 order: 70,
                 format: (config) => config.auto_update.crtr === false ? 'off' : config.auto_update.crtr,
                 cycle: (config, delta) => { config.auto_update.crtr = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.crtr, delta); },
@@ -74,6 +75,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
                 description: 'Notify about plugin and marketplace updates, apply them automatically, or turn checks off.',
                 valueConstraint: 'false|notify|apply',
                 applies: 'Applies on the next crouter command.',
+                group: 'updates',
                 order: 80,
                 format: (config) => config.auto_update.content === false ? 'off' : config.auto_update.content,
                 cycle: (config, delta) => { config.auto_update.content = cycleChoice(AUTO_UPDATE_MODES, config.auto_update.content, delta); },
@@ -90,6 +92,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
                 description: 'Minimum hours between automatic update checks. Zero checks on every command.',
                 valueConstraint: 'integer >= 0',
                 applies: 'Applies on the next crouter command.',
+                group: 'updates',
                 order: 90,
                 format: (config) => `${config.auto_update.interval_hours}h`,
                 cycle: (config, delta) => { config.auto_update.interval_hours = cycleNumber(UPDATE_INTERVAL_HOURS, config.auto_update.interval_hours, delta); },
@@ -111,6 +114,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Maximum human-review panes placed in one tmux window before using another window.',
             valueConstraint: 'integer >= 1',
             applies: 'Applies to the next pane placement.',
+            group: 'panes',
             order: 20,
             format: (config) => String(config.max_panes_per_window),
             cycle: (config, delta) => { config.max_panes_per_window = cycleNumber(MAX_PANES, config.max_panes_per_window, delta); },
@@ -131,6 +135,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Open each managed child beside its watched parent. Off keeps new children running in the background.',
             valueConstraint: 'true|false',
             applies: 'Applies to the next managed child created; independent roots still open their attended viewer.',
+            group: 'panes',
             order: 10,
             format: (config) => config.auto_open_child_viewers ? 'on' : 'off',
             cycle: (config) => { config.auto_open_child_viewers = !config.auto_open_child_viewers; },
@@ -152,6 +157,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Ring a short sound when the node in an attached viewer finishes a turn.',
             valueConstraint: 'true|false',
             applies: 'Applies on the next turn end.',
+            group: 'display',
             order: 40,
             format: (config) => config.completion_bell ? 'on' : 'off',
             cycle: (config) => { config.completion_bell = !config.completion_bell; },
@@ -173,6 +179,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Play the whip animation when you send a prompt and when an automatically opened child viewer starts.',
             valueConstraint: 'true|false',
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 39,
             format: (config) => config.whip_mode ? 'on' : 'off',
             cycle: (config) => { config.whip_mode = !config.whip_mode; },
@@ -194,6 +201,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Initial mouse wheel scrolling for each attached viewer.',
             valueConstraint: MOUSE_MODE_DEFAULTS.join('|'),
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 38,
             format: (config) => config.mouse_mode_default === 'tmux' ? 'follow tmux' : config.mouse_mode_default,
             cycle: (config, delta) => { config.mouse_mode_default = cycleChoice(MOUSE_MODE_DEFAULTS, config.mouse_mode_default, delta); },
@@ -213,6 +221,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Trailing refresh cycles rendered at full fidelity; older cycles condense to text.',
             valueConstraint: 'integer >= 1',
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 50,
             format: (config) => String(config.live_cycles),
             cycle: (config, delta) => { config.live_cycles = cycleNumber(LIVE_CYCLES, config.live_cycles, delta); },
@@ -233,6 +242,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Messages retained from condensed cycles. Tool calls are never kept.',
             valueConstraint: CONDENSED_HISTORY_MODES.join('|'),
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 60,
             format: (config) => config.condensed_history,
             cycle: (config, delta) => { config.condensed_history = cycleChoice(CONDENSED_HISTORY_MODES, config.condensed_history, delta); },
@@ -252,6 +262,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Fold every settled tool call to its call line. Toggle live with /fold-tools.',
             valueConstraint: 'true|false',
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 30,
             format: (config) => config.fold_finished_tools ? 'on' : 'off',
             cycle: (config) => { config.fold_finished_tools = !config.fold_finished_tools; },
@@ -272,6 +283,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Replace completed folded tool-call groups with a one-line broker summary when available.',
             valueConstraint: 'true|false',
             applies: 'Applies when the next visible message closes a tool-call group.',
+            group: 'display',
             order: 35,
             format: (config) => config.summarize_tool_calls ? 'on' : 'off',
             cycle: (config) => { config.summarize_tool_calls = !config.summarize_tool_calls; },
@@ -292,6 +304,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
             description: 'Show each memory read and edited file in folded tool recaps. Off shows a compact count line instead.',
             valueConstraint: 'true|false',
             applies: 'Applies on the next attach.',
+            group: 'display',
             order: 36,
             format: (config) => config.detailed_tool_recaps ? 'on' : 'off',
             cycle: (config) => { config.detailed_tool_recaps = !config.detailed_tool_recaps; },
@@ -327,8 +340,12 @@ function collectUserSettings() {
     }
     return out.sort((a, b) => a.order - b.order);
 }
-/** The single row registry shared by `sys setup` and `sys config set`. */
+/** The single row registry shared by `sys settings` and `sys config set`. */
 export const USER_SETTINGS = collectUserSettings();
 export function findUserSetting(key) {
     return USER_SETTINGS.find((setting) => setting.key === key);
 }
+/** The rows one settings destination owns, in registry order. */
+export function userSettingsInGroup(group) {
+    return USER_SETTINGS.filter((setting) => setting.group === group);
+}

package/dist/daemon/api/__tests__/node-model-validation.test.js

@@ -0,0 +1,134 @@
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, getNode, listNodes } from '../../../core/canvas/canvas.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { CrtrError } from '../../../core/errors.js';
+import { handleConfig, handleCreate, handlePromote, handleYield } from '../handlers/nodes.js';
+const previousCrtrHome = process.env['CRTR_HOME'];
+let home = '';
+before(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-node-model-validation-'));
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (previousCrtrHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousCrtrHome;
+});
+function node(id, cwd = home) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd,
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        parent: null,
+        profile_id: null,
+        launch: { model: 'anthropic/original', extensions: [], env: {} },
+    };
+}
+function ctx(method, path, id, body) {
+    return {
+        method,
+        path,
+        params: { id },
+        query: new URLSearchParams(),
+        body,
+    };
+}
+const missingRegistry = {
+    find: () => undefined,
+    hasConfiguredAuth: () => false,
+};
+async function rejectsUnregistered(action) {
+    await assert.rejects(action, (error) => {
+        assert.ok(error instanceof CrtrError);
+        assert.equal(error.code, 'usage');
+        assert.match(error.message, /openai-codex\/fast/);
+        return true;
+    });
+}
+test('create rejects an unregistered concrete model before creating a node row', async () => {
+    const beforeRows = listNodes().length;
+    const ctx = {
+        method: 'POST',
+        path: '/v1/nodes',
+        params: {},
+        query: new URLSearchParams(),
+        body: {
+            kind: 'developer',
+            root: true,
+            profile: null,
+            cwd: home,
+            prompt: 'must never launch',
+            model: 'openai-codex/fast',
+        },
+    };
+    await assert.rejects(() => handleCreate(ctx, { modelRegistry: missingRegistry }), (error) => {
+        assert.ok(error instanceof CrtrError);
+        assert.equal(error.code, 'usage');
+        assert.match(error.message, /openai-codex\/fast/);
+        assert.match(error.details?.['next'], /ultra\|strong\|medium\|light/);
+        return true;
+    });
+    assert.equal(listNodes().length, beforeRows);
+});
+test('promote and yield reject unregistered model recipes before reshaping the node', async () => {
+    for (const operation of ['promote', 'yield']) {
+        const id = `${operation}-model`;
+        createNode(node(id));
+        const before = getNode(id);
+        const request = ctx('POST', `/v1/nodes/${id}/${operation}`, id, { model: 'openai-codex/fast' });
+        await rejectsUnregistered(() => operation === 'promote'
+            ? handlePromote(request, { modelRegistry: missingRegistry })
+            : handleYield(request, { modelRegistry: missingRegistry }));
+        const after = getNode(id);
+        assert.equal(after?.model_override, before?.model_override, `${operation} did not persist the rejected override`);
+        assert.deepEqual(after?.launch, before?.launch, `${operation} did not rewrite the launch recipe`);
+        assert.equal(after?.mode, before?.mode, `${operation} did not reshape the node`);
+    }
+});
+test('config normalizes portable models against the target node scope', async () => {
+    const cwd = join(home, 'target-project');
+    mkdirSync(join(cwd, '.crouter'), { recursive: true });
+    writeFileSync(join(cwd, '.crouter', 'config.json'), JSON.stringify({
+        modelLadders: {
+            anthropic: {
+                ultra: 'target-anthropic/a-ultra',
+                strong: 'target-anthropic/a-strong',
+                medium: 'target-anthropic/a-medium',
+                light: 'target-anthropic/a-light',
+            },
+            openai: {
+                ultra: 'target-openai/o-ultra',
+                strong: 'target-openai/o-strong',
+                medium: 'target-openai/o-medium',
+                light: 'target-openai/o-light',
+            },
+        },
+    }));
+    const id = 'target-scope-model';
+    createNode(node(id, cwd));
+    const registry = {
+        find: (providerId, modelId) => providerId === 'target-openai' && modelId === 'o-strong' ? { providerId, modelId } : undefined,
+        hasConfiguredAuth: () => false,
+    };
+    await handleConfig(ctx('PATCH', `/v1/nodes/${id}/config`, id, { model: 'openai/strong' }), { modelRegistry: registry });
+    assert.equal(getNode(id)?.model_override, 'target-openai/o-strong');
+    assert.equal(getNode(id)?.launch?.model, 'target-openai/o-strong');
+});

package/dist/daemon/api/__tests__/review-terminal-conflict.test.js

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { closeDb, openDb } from '../../../core/canvas/db.js';
+import { reviewResultPath } from '../../../core/canvas/paths.js';
+import { toErrorBody } from '../map.js';
+import { reviewCommentRoutes } from '../handlers/review-comments.js';
+test('comment create reports the terminal review winner', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-review-terminal-conflict-'));
+    const previousHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    try {
+        const route = reviewCommentRoutes.find((candidate) => candidate.method === 'POST' && candidate.pattern === '/v1/human/reviews/:review_id/comments');
+        assert.ok(route, 'the canonical comment-create route is registered');
+        for (const terminal of [
+            {
+                state: 'canceled',
+                terminalColumns: ['2026-01-02T00:00:00.000Z', null, null, null, null, 'out of band cancel', 'human'],
+                terminalDTO: {
+                    canceled_at: '2026-01-02T00:00:00.000Z',
+                    cancel_reason: 'out of band cancel',
+                    cancel_actor: 'human',
+                },
+            },
+            {
+                state: 'approved',
+                terminalColumns: [null, '2026-01-03T00:00:00.000Z', 1, 2, 1, null, null],
+                terminalDTO: {
+                    approved_at: '2026-01-03T00:00:00.000Z',
+                    changed: true,
+                    comments_total: 2,
+                    comments_unresolved: 1,
+                },
+            },
+        ]) {
+            const reviewId = `${terminal.state}-review`;
+            openDb().prepare(`
+        INSERT INTO reviews
+          (review_id, idempotency_key, origin_kind, origin_node_id, companion_node_id, review_dir,
+           file, origin_session_file, origin_session_id, origin_leaf_id, model_spec, branch_file,
+           baseline_sha256, baseline_bytes, anchor_base_sha256, anchor_base_bytes, state, created, captured_at,
+           canceled_at, approved_at, changed, comments_total, comments_unresolved, cancel_reason, cancel_actor)
+        VALUES (?, ?, 'inline', 'origin', ?, '/tmp/review', '/tmp/source.md',
+                '/tmp/session.jsonl', 'session', 'leaf', 'anthropic/claude', '/tmp/branch.jsonl',
+                'baseline', 4, 'baseline', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(reviewId, `idempotency-${reviewId}`, `${terminal.state}-companion`, Buffer.from('base'), terminal.state, '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z', ...terminal.terminalColumns);
+            let thrown;
+            try {
+                await route.handler({
+                    method: 'POST',
+                    path: `/v1/human/reviews/${reviewId}/comments`,
+                    params: { review_id: reviewId },
+                    query: new URLSearchParams(),
+                    body: {
+                        text: 'late comment',
+                        anchor: { line: 1, end_line: 1 },
+                        doc_hash: 'a'.repeat(64),
+                        actor_node_id: null,
+                    },
+                });
+            }
+            catch (error) {
+                thrown = error;
+            }
+            const { status, body } = toErrorBody(thrown);
+            assert.equal(status, 409);
+            assert.equal(body.error.code, 'review_terminal_conflict');
+            assert.deepEqual(body.error.details, {
+                state: terminal.state,
+                requested: 'comment',
+                review: {
+                    review_id: reviewId,
+                    origin_kind: 'inline',
+                    origin_node_id: 'origin',
+                    bridge_node_id: null,
+                    companion_node_id: `${terminal.state}-companion`,
+                    file: '/tmp/source.md',
+                    state: terminal.state,
+                    created: '2026-01-01T00:00:00.000Z',
+                    source_missing: true,
+                    anchor_base_sha256: 'baseline',
+                    ...terminal.terminalDTO,
+                    ...(terminal.state === 'approved' ? { result_path: reviewResultPath(reviewId) } : {}),
+                },
+            });
+        }
+    }
+    finally {
+        closeDb();
+        rmSync(home, { recursive: true, force: true });
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+    }
+});

package/dist/daemon/api/__tests__/{full → seam}/api-server.test.js

@@ -1,16 +1,14 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/full/api-server.test.ts
+// Run with: node --import tsx/esm --test src/daemon/api/__tests__/seam/api-server.test.ts
 //
 // A-11 — the Stage-A acceptance gate for the crtrd API server (spec §10, plan
 // §Stage A). Proves A1–A8: the `CrtrClient` HTTP+WS transport drives the FULL
 // server → router → handlers → bridge stack over the real unix socket, against a
 // CRTR_HOME-isolated crtrd, with a fake broker engine (zero LLM cost).
 //
-// FULL TIER (real-boot-bound): this file lives in `__tests__/full/` so the
-// runner (scripts/test-runner.mjs, `file.includes('/__tests__/full/')`) gives it
-// the 30s-per-test / CI-only tier, exactly like the tmux-free
-// `src/core/__tests__/full/broker-attach-stream.test.ts` precedent. It is
-// tmux-free (createHeadlessHarness) but boots REAL broker processes, so it is NOT
-// on the fast local loop.
+// COMPILED SEAM (real-boot-bound): this file lives in `__tests__/seam/`, so
+// `npm run test:seam` runs it from emitted JavaScript with the other real broker
+// and tmux journeys. It is tmux-free (createHeadlessHarness) but boots REAL
+// broker processes, so it is outside the ordinary local loop.
 //
 // APPROACH (see this node's a11-plan.md): the harness stands in for crtrd
 // (in-process superviseTick, fake-live-daemon pidfile, isolated CRTR_HOME + the
@@ -29,8 +27,7 @@ import { test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
 import { statSync, existsSync, readFileSync, mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
 import WebSocket from 'ws';
 import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
 import { createAttachKit } from '../../../../core/__tests__/helpers/broker-clients.js';
@@ -331,42 +328,3 @@ test('files/peek: 400-usage (missing + relative) and 404 error mapping', async (
     await assert.rejects(client.peekFile('relative/not/absolute.txt'), (e) => e instanceof ApiError && e.status === 400 && e.code === 'usage', 'relative path → 400 usage');
     await assert.rejects(client.peekFile(join(tmpdir(), 'crtr-peek-does-not-exist-xyz', 'nope.txt')), (e) => e instanceof ApiError && e.status === 404 && e.code === 'not_found', 'nonexistent absolute path → 404 not_found');
 });
-// ---------------------------------------------------------------------------
-// A7 — emitted dist/api/index.js require-graph reaches zero dist/core/* /
-//      dist/clients/*. Static assertion against the EMITTED output — requires a
-//      prior `npm run build`.
-// ---------------------------------------------------------------------------
-test('A7: emitted dist/api/index.js import graph reaches no dist/core/* or dist/clients/*', () => {
-    const ROOT = fileURLToPath(new URL('../../../../../', import.meta.url)); // repo root
-    const entry = join(ROOT, 'dist', 'api', 'index.js');
-    if (!existsSync(entry)) {
-        assert.fail(`dist/api/index.js is missing — run \`npm run build\` before this test (A7 checks emitted output)`);
-    }
-    // Walk the transitive graph over LOCAL relative imports/exports only. Node
-    // built-ins and bare-specifier deps are irrelevant to the CLI/core purity
-    // boundary; any reach into dist/core or dist/clients would surface as a
-    // relative `../core/...` / `../clients/...` specifier resolving into those
-    // trees.
-    const spec = /(?:from|import)\s*['"](\.[^'"]+)['"]/g;
-    const seen = new Set();
-    const stack = [entry];
-    while (stack.length > 0) {
-        const file = stack.pop();
-        if (seen.has(file))
-            continue;
-        seen.add(file);
-        let src;
-        try {
-            src = readFileSync(file, 'utf8');
-        }
-        catch {
-            continue; // a .d.ts-only or absent sibling — not part of the runtime graph
-        }
-        for (let m = spec.exec(src); m !== null; m = spec.exec(src)) {
-            stack.push(resolve(dirname(file), m[1]));
-        }
-    }
-    const leaks = [...seen].filter((f) => f.includes('/dist/core/') || f.includes('/dist/clients/'));
-    assert.deepEqual(leaks, [], `dist/api must not reach dist/core/* or dist/clients/* — leaked into:\n${leaks.join('\n')}`);
-    assert.ok(seen.size > 1, 'the graph walk actually followed dist/api imports (sanity)');
-});

package/dist/daemon/api/__tests__/{full → seam}/b10-attach-modelauth.test.js

@@ -1,4 +1,4 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/full/b10-attach-modelauth.test.ts
+// Run with: node --import tsx/esm --test src/daemon/api/__tests__/seam/b10-attach-modelauth.test.ts
 //
 // B-10 acceptance gate (spec §7.2 surface-attach hybrid + §7.6 model-auth
 // install). Proves spec acceptance **B2** for the two client swaps this batch
@@ -14,10 +14,9 @@
 //      /model-auth/{provider}): collection stays client-side; the route persists
 //      the credential to auth.json, which crtrd's mtime watcher fans as
 //      `reload_auth` to live brokers. B2 shape: auth.json write (assert content) +
-//      the reload FAN (assert the reloadAuthLive RPC acks against a live broker) +
-//      old-path vs API-path STRUCTURAL PARITY (byte-identical auth.json).
+//      the reload FAN (assert the reloadAuthLive RPC acks against a live broker).
 //
-// FULL TIER (real-boot-bound): lives in `__tests__/full/` for the 30s-per-test /
+// COMPILED SEAM (real-boot-bound): lives in `__tests__/seam/` for the 30s-per-test /
 // CI-only tier, exactly like api-server.test.ts (the A-11 sibling). tmux-free
 // (createHeadlessHarness) but boots REAL broker processes with the fake engine
 // (zero LLM cost). Reuses A-11's approach: createApiServer() in-process binds the
@@ -117,7 +116,7 @@ test('B2-attach: ensureAttach revives a dormant node, snapshot streams, detach l
 // reload FAN acks against a live broker, and the API path is byte-identical to
 // the old direct-write path.
 // ---------------------------------------------------------------------------
-test('B2-modelauth: installCredential writes auth.json, the reload fan acks a live broker, API path == old path', async () => {
+test('B2-modelauth: installCredential writes auth.json and the reload fan acks a live broker', async () => {
     // Sandbox pi's credential store so the write lands in a throwaway dir, never the
     // developer's real ~/.pi/agent/auth.json. authPath() honors PI_CODING_AGENT_DIR.
     const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
@@ -142,19 +141,6 @@ test('B2-modelauth: installCredential writes auth.json, the reload fan acks a li
         //     watcher invokes after this write; the mtime poll itself is crtrd-internal
         //     and out of B-10's scope — see the honest-proxy note in the header). ---
         await assert.doesNotReject(reloadAuthLive(liveId), 'reloadAuthLive resolves — the live broker acked the reload_auth fan after the auth.json write');
-        // --- STRUCTURAL PARITY: the old path (setup.ts wrote directly via
-        //     a direct credential write to authPath()). Write
-        //     that same credential into a second sandbox and assert byte-identical
-        //     auth.json — the API swap changed the CALLER, not the on-disk structure. ---
-        const oldDir = mkdtempSync(join(tmpdir(), 'crtr-b10-old-'));
-        try {
-            await setAuthCredential('anthropic', { type: 'api_key', key: 'sk-b10-test-key' }, join(oldDir, 'auth.json'));
-            const oldContents = readFileSync(join(oldDir, 'auth.json'), 'utf8');
-            assert.equal(apiContents, oldContents, 'API-path auth.json is byte-identical to the old direct-write path (structural parity)');
-        }
-        finally {
-            rmSync(oldDir, { recursive: true, force: true });
-        }
     }
     finally {
         if (savedPiDir === undefined)
@@ -167,15 +153,12 @@ test('B2-modelauth: installCredential writes auth.json, the reload fan acks a li
 // ---------------------------------------------------------------------------
 // B2 (model-auth, oauth) — non-managed OAuth install must PRESERVE
 // provider-specific extra credential fields (e.g. github-copilot's
-// `enterpriseUrl`, load-bearing for enterprise routing/refresh). OLD
-// `AuthStorage.login` spread the FULL credential object; the API swap forwards
-// non-standard keys through `extra` and the handler re-spreads them. Regression
-// guard for review M1 (a dropped enterpriseUrl breaks GitHub-Enterprise Copilot).
-// Parity here is STRUCTURAL (parsed deep-equal), not byte-identical: the
-// extra-then-tokens spread order legitimately differs from OLD's credential key
-// order, but the stored credential is the same object.
+// `enterpriseUrl`, load-bearing for enterprise routing/refresh). The client
+// forwards non-standard keys through `extra` and the handler re-spreads them.
+// Regression guard for review M1 (a dropped enterpriseUrl breaks
+// GitHub-Enterprise Copilot).
 // ---------------------------------------------------------------------------
-test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enterpriseUrl) — structural parity with OLD login spread', async () => {
+test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enterpriseUrl)', async () => {
     const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
     const apiDir = mkdtempSync(join(tmpdir(), 'crtr-b10-oauth-api-'));
     process.env['PI_CODING_AGENT_DIR'] = apiDir;
@@ -192,24 +175,14 @@ test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enter
         const apiContents = readFileSync(join(apiDir, 'auth.json'), 'utf8');
         assert.ok(apiContents.includes('enterpriseUrl'), 'enterpriseUrl key survived the swap (M1 regression guard)');
         assert.ok(apiContents.includes('ghe.example.com'), 'the enterprise domain value is preserved');
-        // OLD path: the login persist wrote { type:'oauth', ...credentials } —
-        // spreading the FULL credential (tokens + enterpriseUrl + availableModelIds).
-        const oldDir = mkdtempSync(join(tmpdir(), 'crtr-b10-oauth-old-'));
-        try {
-            await setAuthCredential('github-copilot', {
-                type: 'oauth',
-                access: 'gho-access-xyz',
-                refresh: 'ghr-refresh-xyz',
-                expires: expiresMs,
-                enterpriseUrl: 'https://ghe.example.com',
-                availableModelIds: ['gpt-4o'],
-            }, join(oldDir, 'auth.json'));
-            const oldContents = readFileSync(join(oldDir, 'auth.json'), 'utf8');
-            assert.deepEqual(JSON.parse(apiContents), JSON.parse(oldContents), 'oauth API-path auth.json is structurally identical to the OLD full-spread login path (no field dropped)');
-        }
-        finally {
-            rmSync(oldDir, { recursive: true, force: true });
-        }
+        assert.deepEqual(JSON.parse(apiContents)['github-copilot'], {
+            type: 'oauth',
+            enterpriseUrl: 'https://ghe.example.com',
+            availableModelIds: ['gpt-4o'],
+            access: 'gho-access-xyz',
+            refresh: 'ghr-refresh-xyz',
+            expires: expiresMs,
+        }, 'the stored oauth credential carries the tokens AND every extra field');
     }
     finally {
         if (savedPiDir === undefined)