@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/broker-launch-candidates.test.js

@@ -1,311 +0,0 @@
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createAgentSessionFromServices, createAgentSessionServices, SessionManager, VERSION } from '../runtime/broker-sdk.js';
-import { buildBrokerSession } from '../runtime/broker.js';
-import { createNode } from '../canvas/canvas.js';
-import { beginExecution } from '../canvas/executions.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { unregisteredConcreteModel } from '../model-routes.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { resetScopeCache } from '../scope.js';
-import { piAgentDir } from '../runtime/package-health.js';
-import { createApiServer } from '../../daemon/api/server.js';
-import { isUnknownModel } from '../runtime/model-selection.js';
-import { resolveProviderCandidates } from '../subscription-state.js';
-const realEngine = { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION };
-const C3_EXT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'c3-custom-provider-ext.ts');
-const previousModelIntent = process.env['CRTR_MODEL_INTENT'];
-const previousHome = process.env['HOME'];
-let home;
-before(() => {
-    delete process.env['CRTR_MODEL_INTENT'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-home-'));
-    process.env['HOME'] = home;
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    initializeFreshScopedStore({ kind: 'provider', root: piAgentDir() });
-});
-after(() => {
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    if (previousModelIntent === undefined)
-        delete process.env['CRTR_MODEL_INTENT'];
-    else
-        process.env['CRTR_MODEL_INTENT'] = previousModelIntent;
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    resetScopeCache();
-});
-const requested = { provider: 'anthropic', id: 'requested' };
-const alternative = { provider: 'openai-codex', id: 'alternative' };
-const DEFAULT_MANAGED_PROVIDERS = new Set(['anthropic', 'openai-codex']);
-// The unified `resolveProviderCandidates` is the ONE resolver governing launch,
-// turn-time retry, and rotation fallback (issue #236). This adapter reproduces
-// the launch caller's contract — requested model first (its provider pinned when
-// pinned), then registry order — and maps the result back to the original
-// `{ model, rejections }` shape so every launch behavior assertion below still
-// holds against the surviving resolver.
-const REJECTION_TEXT = {
-    unregistered: 'not registered',
-    unauthenticated: 'provider has no configured credentials',
-    cooling: 'managed provider is cooling down',
-    'non-managed-fallback': 'non-managed provider is not an automatic fallback',
-};
-function resolve(options) {
-    const key = (provider, id) => `${provider}/${id}`;
-    const registered = new Set((options.registered ?? options.available).map((m) => key(m.provider, m.id)));
-    const authenticated = new Set((options.authenticated ?? options.available).map((m) => key(m.provider, m.id)));
-    const cooling = new Set((options.cooling ?? []).map((m) => key(m.provider, m.id)));
-    const COOL_UNTIL = Date.now() + 10 * 60_000;
-    // Ordered candidate set: requested provider/id first, then available in order.
-    const ordered = [];
-    const seen = new Set();
-    const push = (provider, id) => {
-        const k = key(provider, id);
-        if (seen.has(k))
-            return;
-        seen.add(k);
-        ordered.push({ provider, id });
-    };
-    if (options.requested !== undefined && options.requested !== '') {
-        const slash = options.requested.indexOf('/');
-        push(options.requested.slice(0, slash), options.requested.slice(slash + 1));
-    }
-    for (const m of options.available)
-        push(m.provider, m.id);
-    // Mirrors resolveLaunchModel's own first pass: a non-managed candidate is
-    // only an automatic fallback when no managed provider is registered AND
-    // authenticated anywhere in this candidate set, regardless of cooling.
-    const hasManagedAuthenticated = ordered.some((m) => DEFAULT_MANAGED_PROVIDERS.has(m.provider) && registered.has(key(m.provider, m.id)) && authenticated.has(key(m.provider, m.id)));
-    const result = resolveProviderCandidates(ordered.map((m, index) => ({
-        providerId: m.provider,
-        modelId: m.id,
-        automaticFallback: index === 0 && options.requested !== undefined && options.requested !== ''
-            ? true
-            : DEFAULT_MANAGED_PROVIDERS.has(m.provider) || !hasManagedAuthenticated,
-        registered: registered.has(key(m.provider, m.id)),
-        authenticated: registered.has(key(m.provider, m.id)) && authenticated.has(key(m.provider, m.id)),
-        coolingUntil: cooling.has(key(m.provider, m.id)) ? COOL_UNTIL : undefined,
-    })), Date.now(), { pinnedToFirst: options.modelProviderPinned === true && options.requested !== undefined && options.requested !== '' });
-    // Return the ORIGINAL Model object by reference so identity assertions hold.
-    const pools = [options.available, options.registered ?? [], options.authenticated ?? [], options.cooling ?? []];
-    const findModel = (provider, id) => {
-        for (const pool of pools) {
-            const m = pool.find((x) => x.provider === provider && x.id === id);
-            if (m !== undefined)
-                return m;
-        }
-        return { provider, id };
-    };
-    const selected = result.candidates[0];
-    return {
-        model: selected === undefined ? undefined : findModel(selected.providerId, selected.modelId),
-        rejections: result.rejected.map(({ candidate, reason }) => ({
-            spec: key(candidate.providerId, candidate.modelId),
-            reason: REJECTION_TEXT[reason],
-        })),
-    };
-}
-test('an unregistered concrete recipe is a permanent failure, but missing auth is not', () => {
-    // The two outcomes route differently at launch: an unregistered model can
-    // never boot and must fault, while a registered model with no configured auth
-    // is recoverable once credentials arrive.
-    const known = { provider: 'openai-codex', id: 'o-strong' };
-    const registry = {
-        find: (providerId, modelId) => providerId === known.provider && modelId === known.id ? known : undefined,
-        hasConfiguredAuth: () => false,
-    };
-    const unknown = unregisteredConcreteModel({ kind: 'concrete', spec: 'openai-codex/fast' }, registry, { profileId: null });
-    assert.equal(unknown?.reason, 'unregistered');
-    assert.equal(unknown?.candidate.providerId, 'openai-codex');
-    assert.equal(unknown?.candidate.modelId, 'fast');
-    assert.equal(unregisteredConcreteModel({ kind: 'concrete', spec: 'openai-codex/o-strong' }, registry, { profileId: null }), undefined, 'a registered model remains recoverable even when it has no configured auth');
-});
-test('launch candidate resolver keeps a healthy explicit provider pin ahead of authenticated alternatives', () => {
-    const result = resolve({ requested: 'anthropic/requested', available: [alternative, requested], modelProviderPinned: true });
-    assert.equal(result.model, requested);
-    assert.deepEqual(result.rejections, []);
-});
-test('launch candidate resolver selects a non-managed candidate as automatic fallback when no managed provider is authenticated', () => {
-    const localModel = { provider: 'lm-studio', id: 'qwen' };
-    const result = resolve({ requested: 'missing/missing', available: [localModel] });
-    assert.equal(result.model, localModel);
-    assert.deepEqual(result.rejections, [
-        { spec: 'missing/missing', reason: 'not registered' },
-    ]);
-});
-test('broker launch rejects an unregistered concrete model even when a non-managed provider is available', async () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-'));
-    const priorCanvasHome = process.env['CRTR_HOME'];
-    const priorNodeId = process.env['CRTR_NODE_ID'];
-    const priorExecutionId = process.env['CRTR_EXECUTION_ID'];
-    const nodeId = 'launch-candidate';
-    closeDb();
-    process.env['CRTR_HOME'] = home;
-    process.env['CRTR_NODE_ID'] = nodeId;
-    migrate(openDb());
-    createNode({ node_id: nodeId, name: nodeId, created: new Date().toISOString(), cwd, kind: 'developer', mode: 'base', lifecycle: 'resident', status: 'active' });
-    process.env['CRTR_EXECUTION_ID'] = beginExecution(nodeId, { daemonEpoch: 'test' });
-    const server = createApiServer();
-    await server.ready;
-    try {
-        const engine = {
-            ...realEngine,
-            async createAgentSessionServices(options) {
-                const services = await realEngine.createAgentSessionServices(options);
-                const custom = services.modelRuntime.getModel('c3prov', 'c3model');
-                // The broker reads models through pi's sync ModelRegistry facade, which delegates
-                // getAll/getAvailable/hasConfiguredAuth straight to these three runtime methods.
-                const modelRuntime = Object.create(services.modelRuntime);
-                modelRuntime.getModels = () => [custom];
-                modelRuntime.getAvailableSnapshot = () => [custom];
-                modelRuntime.hasConfiguredAuth = (providerId) => providerId === custom.provider;
-                return { ...services, modelRuntime };
-            },
-        };
-        await assert.rejects(buildBrokerSession(engine, { cwd, extensionPaths: [C3_EXT], model: 'missing/missing' }), /FATAL: model 'missing\/missing' is not registered/);
-    }
-    finally {
-        await server.close();
-        closeDb();
-        if (priorCanvasHome === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = priorCanvasHome;
-        if (priorNodeId === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = priorNodeId;
-        if (priorExecutionId === undefined)
-            delete process.env['CRTR_EXECUTION_ID'];
-        else
-            process.env['CRTR_EXECUTION_ID'] = priorExecutionId;
-        rmSync(cwd, { recursive: true, force: true });
-    }
-});
-test('broker launch honors an explicitly requested non-managed provider', async () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-'));
-    try {
-        const { session } = await buildBrokerSession(realEngine, { cwd, extensionPaths: [C3_EXT], model: 'c3prov/c3model' });
-        try {
-            assert.equal(`${session.model?.provider}/${session.model?.id}`, 'c3prov/c3model');
-        }
-        finally {
-            session.dispose();
-        }
-    }
-    finally {
-        rmSync(cwd, { recursive: true, force: true });
-    }
-});
-test('launch candidate resolver rejects an unregistered explicit provider pin without trying alternatives', () => {
-    const result = resolve({
-        requested: 'anthropic/missing',
-        available: [alternative],
-        modelProviderPinned: true,
-    });
-    assert.equal(result.model, undefined);
-    assert.deepEqual(result.rejections, [{ spec: 'anthropic/missing', reason: 'not registered' }]);
-});
-test('launch candidate resolver rejects an unauthenticated explicit provider pin without trying alternatives', () => {
-    const result = resolve({
-        requested: 'anthropic/requested',
-        available: [requested, alternative],
-        authenticated: [alternative],
-        modelProviderPinned: true,
-    });
-    assert.equal(result.model, undefined);
-    assert.deepEqual(result.rejections, [{ spec: 'anthropic/requested', reason: 'provider has no configured credentials' }]);
-});
-test('launch candidate resolver tries a cross-provider alternative when an explicit managed provider pin is cooling', () => {
-    const result = resolve({
-        requested: 'anthropic/requested',
-        available: [requested, alternative],
-        cooling: [requested],
-        modelProviderPinned: true,
-    });
-    assert.equal(result.model, alternative);
-    assert.deepEqual(result.rejections, [{ spec: 'anthropic/requested', reason: 'managed provider is cooling down' }]);
-});
-test('launch candidate resolver leaves no model selected when every candidate is unavailable, unauthenticated, or cooling', () => {
-    const unconfigured = { provider: 'openai-codex', id: 'unconfigured' };
-    const result = resolve({
-        requested: 'anthropic/missing',
-        available: [unconfigured, requested],
-        registered: [unconfigured, requested],
-        authenticated: [requested],
-        cooling: [requested],
-    });
-    assert.equal(result.model, undefined);
-    assert.deepEqual(result.rejections, [
-        { spec: 'anthropic/missing', reason: 'not registered' },
-        { spec: 'openai-codex/unconfigured', reason: 'provider has no configured credentials' },
-        { spec: 'anthropic/requested', reason: 'managed provider is cooling down' },
-    ]);
-});
-test('launch candidate resolver blocks a non-managed fallback while a managed provider is authenticated, even though it is currently cooling', () => {
-    const managedCooling = { provider: 'anthropic', id: 'managed' };
-    const localModel = { provider: 'lm-studio', id: 'qwen' };
-    const result = resolve({
-        requested: 'missing/missing',
-        available: [managedCooling, localModel],
-        authenticated: [managedCooling, localModel],
-        cooling: [managedCooling],
-    });
-    assert.equal(result.model, undefined);
-    assert.deepEqual(result.rejections, [
-        { spec: 'missing/missing', reason: 'not registered' },
-        { spec: 'anthropic/managed', reason: 'managed provider is cooling down' },
-        { spec: 'lm-studio/qwen', reason: 'non-managed provider is not an automatic fallback' },
-    ]);
-});
-test('launch candidate resolver leaves no model selected on a genuine zero-auth boot', () => {
-    const result = resolve({ requested: 'anthropic/missing', available: [] });
-    assert.equal(result.model, undefined);
-});
-test('real SDK contract: a model-less session boots to the unknown-stub (never undefined) and prompt() rejects on missing auth', async () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-'));
-    const agentDir = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-agent-'));
-    try {
-        const services = await realEngine.createAgentSessionServices({ cwd, agentDir });
-        const sessionManager = realEngine.SessionManager.create(cwd);
-        const { session } = await realEngine.createAgentSessionFromServices({
-            services,
-            sessionManager,
-            model: undefined,
-            tools: [],
-        });
-        try {
-            // The pinned pi SDK NEVER yields `session.model === undefined` for a
-            // model-less construction: Agent.createMutableAgentState() falls back to a
-            // hardcoded `{ provider:'unknown', id:'unknown', api:'unknown', … }` stub.
-            // A literal `=== undefined` guard (which the fake engine satisfies) is
-            // therefore DEAD in production — the broker's isUnknownModel() is what
-            // actually recognizes this stub as "no model", so pin the contract here.
-            assert.notEqual(session.model, undefined);
-            assert.equal(session.model?.provider, 'unknown');
-            assert.equal(session.model?.id, 'unknown');
-            assert.equal(isUnknownModel(session.model), true);
-            // prompt() against the stub rejects on the MISSING API KEY — the SDK's
-            // `if (!this.model)` "No model selected" guard is never reached because
-            // the stub is truthy — so a model-less boot is only usable once a /login
-            // re-drive selects a real model.
-            await assert.rejects(() => session.prompt('hi'), /no api key found/i);
-        }
-        finally {
-            session.dispose();
-        }
-    }
-    finally {
-        rmSync(cwd, { recursive: true, force: true });
-        rmSync(agentDir, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/broker-preflight.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/broker-preflight.test.js

@@ -1,95 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-preflight.test.ts
-//
-// Bug-regression: preflight broker launch validation should resolve the default
-// broker package, reject broken custom engines, and fail before a detached broker
-// process is spawned when session args are invalid or missing.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { preflightBrokerLaunch } from '../runtime/host.js';
-import { CANVAS_EXTENSIONS } from '../runtime/launch.js';
-const HERE = dirname(fileURLToPath(import.meta.url));
-const FAKE_ENGINE = join(HERE, 'fixtures', 'fake-engine.ts');
-let home;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-preflight-'));
-    process.env['CRTR_HOME'] = home;
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-function validArgv(...tail) {
-    return [...CANVAS_EXTENSIONS.flatMap((path) => ['-e', path]), ...tail];
-}
-function assertLaunchWrote(nodeId, inv) {
-    const launchPath = join(home, 'nodes', nodeId, 'broker-launch.json');
-    const parsed = JSON.parse(readFileSync(launchPath, 'utf8'));
-    assert.deepEqual(parsed, inv, 'the launch recipe exists and parses as JSON');
-}
-test('preflightBrokerLaunch uses the installed default broker package when no engine override is set', () => {
-    const nodeId = 'preflight-default-engine';
-    const inv = {
-        argv: validArgv('hello'),
-        env: {},
-    };
-    const prev = process.env['CRTR_BROKER_ENGINE'];
-    delete process.env['CRTR_BROKER_ENGINE'];
-    try {
-        assert.doesNotThrow(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'));
-    }
-    finally {
-        if (prev === undefined)
-            delete process.env['CRTR_BROKER_ENGINE'];
-        else
-            process.env['CRTR_BROKER_ENGINE'] = prev;
-    }
-    assertLaunchWrote(nodeId, inv);
-});
-test('preflightBrokerLaunch fails fast when the broker engine module cannot be resolved', () => {
-    const nodeId = 'preflight-bad-engine';
-    const inv = {
-        argv: validArgv('hello'),
-        env: { CRTR_BROKER_ENGINE: '@crouton-kit/does-not-exist' },
-    };
-    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /cannot resolve broker engine/i);
-    assertLaunchWrote(nodeId, inv);
-});
-test('preflightBrokerLaunch rejects missing or duplicate mandatory canvas hooks before broker readiness', () => {
-    const missing = { argv: ['hello'], env: { CRTR_BROKER_ENGINE: FAKE_ENGINE } };
-    assert.throws(() => preflightBrokerLaunch('preflight-missing-hook', missing, '/tmp/work'), /canvas extension.*found 0/i);
-    const duplicate = { argv: [...validArgv(), '-e', CANVAS_EXTENSIONS[0], 'hello'], env: { CRTR_BROKER_ENGINE: FAKE_ENGINE } };
-    assert.throws(() => preflightBrokerLaunch('preflight-duplicate-hook', duplicate, '/tmp/work'), /duplicate mandatory canvas extension basename canvas-inbox-watcher/i);
-});
-test('preflightBrokerLaunch validates the exact broker engine env passed to the detached broker', () => {
-    const nodeId = 'preflight-empty-engine';
-    const inv = {
-        argv: validArgv('hello'),
-        env: { CRTR_BROKER_ENGINE: '   ' },
-    };
-    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /cannot resolve broker engine/i);
-    assertLaunchWrote(nodeId, inv);
-});
-test('preflightBrokerLaunch fails fast when a bare --session id would be rejected by the broker', () => {
-    const nodeId = 'preflight-bare-session';
-    const inv = {
-        argv: validArgv('--session', 'uuid-123'),
-        env: { CRTR_BROKER_ENGINE: FAKE_ENGINE },
-    };
-    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /bare --session id/i);
-    assertLaunchWrote(nodeId, inv);
-});
-test('preflightBrokerLaunch fails fast when a plainly-encoded session file path is missing', () => {
-    const nodeId = 'preflight-missing-session';
-    const inv = {
-        argv: validArgv('--session', join(home, 'sessions', 'missing.jsonl')),
-        env: { CRTR_BROKER_ENGINE: FAKE_ENGINE },
-    };
-    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /missing session file/i);
-    const launchPath = join(home, 'nodes', nodeId, 'broker-launch.json');
-    const parsed = JSON.parse(readFileSync(launchPath, 'utf8'));
-    assert.deepEqual(parsed, inv, 'the launch recipe exists and parses as JSON');
-});

package/dist/core/__tests__/broker-stream-watchdog-floor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/broker-stream-watchdog-floor.test.js

@@ -1,82 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { EventProjection } from '../runtime/broker/event-projection.js';
-import { RebindDriver } from '../runtime/broker/rebind.js';
-function generationFor(session) {
-    return {
-        id: 1,
-        session,
-        fallback: { blocked: false },
-        stagedProviderAgentEnd: null,
-        stagedWatchdogAbort: false,
-        stagedRefreshAbort: false,
-        stagedOverflowFailure: null,
-        executingTools: new Set(),
-    };
-}
-function projectionFor(session, generation) {
-    return new EventProjection({
-        registry: { broadcast: () => undefined },
-        faultRetry: { onEvent: () => undefined, clearTimer: () => undefined },
-        installedGeneration: () => generation,
-        currentSession: () => session,
-        notifyTurnAccepted: () => undefined,
-        emitStartupMilestone: () => undefined,
-        formatModelSpec: () => null,
-    });
-}
-test('agent_start arms the provider watchdog before another engine event arrives', (t) => {
-    t.mock.timers.enable({ apis: ['setTimeout'] });
-    let aborts = 0;
-    const session = { isStreaming: true, abort: async () => { aborts++; } };
-    const generation = generationFor(session);
-    const projection = projectionFor(session, generation);
-    projection.relayEvent({ type: 'agent_start' }, generation);
-    t.mock.timers.tick(5 * 60_000);
-    assert.equal(aborts, 1, 'the initial streaming event leaves a watchdog floor even if the engine falls silent immediately');
-    assert.equal(generation.stagedWatchdogAbort, true, 'the floor retains watchdog provenance for provider-fault recovery');
-});
-test('tool execution replaces the provider watchdog with the long ceiling', (t) => {
-    t.mock.timers.enable({ apis: ['setTimeout'] });
-    let aborts = 0;
-    const session = { isStreaming: true, abort: async () => { aborts++; } };
-    const generation = generationFor(session);
-    const projection = projectionFor(session, generation);
-    projection.relayEvent({ type: 'agent_start' }, generation);
-    projection.relayEvent({ type: 'tool_execution_start', toolCallId: 'stuck-tool' }, generation);
-    t.mock.timers.tick(5 * 60_000);
-    assert.equal(aborts, 0, 'a tool outlives the ordinary five-minute provider watchdog');
-    t.mock.timers.tick(15 * 60_000);
-    assert.equal(aborts, 1, 'a silent in-process tool cannot clear all watchdog coverage indefinitely');
-});
-test('rebind rearms the watchdog floor for a still-streaming replacement session', async () => {
-    const calls = [];
-    const projection = {
-        reset: () => calls.push('reset'),
-        rearmIfStreaming: (generation) => calls.push(`rearm:${generation.id}`),
-    };
-    const session = {
-        isStreaming: true,
-        systemPrompt: '',
-        bindExtensions: async () => undefined,
-        subscribe: () => () => undefined,
-    };
-    const driver = new RebindDriver({
-        nodeId: 'watchdog-floor-rebind',
-        cfg: {},
-        session,
-        services: {},
-        runtime: undefined,
-        uiContext: () => ({}),
-        registry: {},
-        toolGroups: { resetForSession: () => undefined },
-        faultRetry: () => ({ reset: () => undefined }),
-        projection: () => projection,
-        setActiveSession: () => undefined,
-        disposeAndExit: () => undefined,
-        onSessionRebind: () => undefined,
-        reWelcomeAll: () => undefined,
-    });
-    await driver.enqueueRebind(session, {});
-    assert.deepEqual(calls, ['reset', 'rearm:1'], 'a rebind that resets projection state immediately restores coverage for its live stream');
-});

package/dist/core/__tests__/broker-turn-admission.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/broker-turn-admission.test.js

@@ -1,44 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { createTurnAdmissionGate } from '../runtime/broker/turn-admission.js';
-function deferred() {
-    let resolve;
-    const promise = new Promise((done) => {
-        resolve = done;
-    });
-    return { promise, resolve };
-}
-test('concurrent starts admit one turn and reject the loser without a spurious settlement', async () => {
-    const gate = createTurnAdmissionGate();
-    const preflight = deferred();
-    const turn = deferred();
-    const enteredPreflight = deferred();
-    let streaming = false;
-    let admittedTurns = 0;
-    let settlements = 0;
-    const prompt = async (release) => {
-        enteredPreflight.resolve();
-        await preflight.promise;
-        if (streaming) {
-            release();
-            throw new Error('Agent is already processing');
-        }
-        streaming = true;
-        admittedTurns++;
-        release();
-        await turn.promise;
-        streaming = false;
-        settlements++;
-    };
-    const winner = gate.admit(prompt);
-    await enteredPreflight.promise;
-    const loser = gate.admit(prompt);
-    preflight.resolve();
-    await assert.rejects(loser, /Agent is already processing/);
-    assert.equal(admittedTurns, 1, 'only the winner entered a turn');
-    assert.equal(settlements, 0, 'the rejected call did not settle the live turn');
-    assert.equal(streaming, true, 'the winner remains live after the loser rejects');
-    turn.resolve();
-    await winner;
-    assert.equal(settlements, 1, 'the admitted turn alone settled');
-});

package/dist/core/__tests__/canvas-db-boundary.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/canvas-db-boundary.test.js

@@ -1,46 +0,0 @@
-// canvas.ts declares itself "the one place that reads/writes the node+edge
-// model" for the runtime layer (spawn, push, lifecycle, daemon) that builds on
-// it — every node/edge write from `runtime/` goes through a named canvas.ts
-// accessor, never a raw SQL statement of its own. This grep-enforces that
-// boundary at the one layer the convention actually claims: `core/runtime/`.
-// (Other canvas.db tables — reviews, review_comments — are a SEPARATE
-// subsystem's tables with their own owner in `core/review/`, and `feed.ts`'s
-// `commitCanonicalFinal` is the one documented sanctioned exception outside
-// `runtime/` entirely — see `core/canvas/.crouter/memory/INDEX.md` — so
-// neither is in scope here.)
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-const RUNTIME_ROOT = resolve(process.cwd(), 'src/core/runtime');
-function tsFilesUnder(dir) {
-    const out = [];
-    for (const entry of readdirSync(dir)) {
-        const path = join(dir, entry);
-        const stat = statSync(path);
-        if (stat.isDirectory()) {
-            if (entry === '__tests__')
-                continue;
-            out.push(...tsFilesUnder(path));
-        }
-        else if (entry.endsWith('.ts') && !entry.endsWith('.test.ts')) {
-            out.push(path);
-        }
-    }
-    return out;
-}
-test('no file under core/runtime/ prepares a raw SQL statement — canvas.ts is the one node+edge DAO', () => {
-    const offenders = [];
-    for (const file of tsFilesUnder(RUNTIME_ROOT)) {
-        const source = readFileSync(file, 'utf8');
-        const lines = source.split('\n');
-        lines.forEach((line, index) => {
-            // Skip comment lines referencing `.prepare(` in prose (backtick-quoted).
-            if (/`\.prepare\(`/.test(line))
-                return;
-            if (line.includes('.prepare('))
-                offenders.push(`${file}:${index + 1}`);
-        });
-    }
-    assert.deepEqual(offenders, [], `raw .prepare( call(s) outside core/canvas/:\n${offenders.join('\n')}`);
-});

package/dist/core/__tests__/canvas-inbox-watcher-hold.test.d.ts

@@ -1 +0,0 @@
-export {};