@lensagent/core 0.1.1 → 0.1.2

package/dist/core/context-boundaries.js

@@ -0,0 +1,106 @@
+import { fail } from './domain.js';
+/** Cuts are positions between messages. IDs are scoped to a batch, not the session. */
+export function contextBoundaries(messages, unsettledItemIds = []) {
+    const unsettled = new Set(unsettledItemIds);
+    const legalCuts = [0];
+    const protectedRanges = [];
+    const violations = [];
+    const pending = new Map();
+    let start = -1;
+    let executionPending = false;
+    for (const [index, message] of messages.entries()) {
+        if (unsettled.has(message.contextItemId ?? ''))
+            executionPending = true;
+        if (message.toolCalls !== undefined) {
+            if (message.role !== 'assistant' || message.toolCalls.length === 0 || pending.size > 0) {
+                violations.push({ index, reason: 'Invalid or overlapping tool call batch.' });
+            }
+            if (start < 0)
+                start = index;
+            for (const call of message.toolCalls) {
+                if (pending.has(call.id))
+                    violations.push({ index, reason: `Duplicate tool call ${call.id}.` });
+                pending.set(call.id, call.name);
+            }
+        }
+        else if (message.role === 'tool') {
+            const name = pending.get(message.toolCallId ?? '');
+            if (name === undefined || name !== message.toolName) {
+                violations.push({ index, reason: 'Orphan, duplicate, or mismatched tool result.' });
+            }
+            else
+                pending.delete(message.toolCallId);
+        }
+        else if (pending.size > 0) {
+            violations.push({ index, reason: 'A non-result message interrupts a tool batch.' });
+        }
+        if (pending.size === 0 && !executionPending) {
+            if (start >= 0)
+                protectedRanges.push({ start, end: index + 1, complete: true });
+            start = -1;
+            legalCuts.push(index + 1);
+        }
+    }
+    if (start >= 0 || executionPending)
+        protectedRanges.push({ start: start < 0 ? (legalCuts.at(-1) ?? 0) : start, end: messages.length, complete: false });
+    return { legalCuts, protectedRanges, violations };
+}
+export function assertContextBoundaries(messages, options = {}) {
+    const boundaries = contextBoundaries(messages, options.unsettledItemIds);
+    if (boundaries.violations.length > 0 || (options.allowOpenTail !== true && boundaries.legalCuts.at(-1) !== messages.length)) {
+        fail('CONTEXT_BOUNDARY_INVALID', 409, 'Context contains an invalid or unfinished protocol group.', {
+            legal_cuts: boundaries.legalCuts,
+            violations: boundaries.violations,
+            protected_ranges: boundaries.protectedRanges
+        });
+    }
+    return boundaries;
+}
+/** Preserve source membership, even if two different batches reuse the same wire IDs. */
+export function assertContextTransition(before, after, unsettledItemIds) {
+    const boundaries = assertContextBoundaries(before, { allowOpenTail: true, unsettledItemIds });
+    const positions = new Map(after.map((message, index) => [message.contextItemId, index]));
+    for (const range of boundaries.protectedRanges) {
+        const members = before.slice(range.start, range.end).map((message) => message.contextItemId);
+        const retained = members.map((id) => positions.get(id));
+        if (range.complete && retained.every((position) => position === undefined))
+            continue;
+        const start = retained[0];
+        if (start === undefined || retained.some((position, index) => position !== start + index)) {
+            fail('CONTEXT_BOUNDARY_INVALID', 409, 'Context operation must preserve or remove the whole protocol group in source order.', {
+                member_ids: members.map((id) => id ?? ''), complete: range.complete
+            });
+        }
+    }
+}
+export function contextToolCalls(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        fail('CONTEXT_BOUNDARY_INVALID', 409, 'Invalid tool batch JSON.');
+    }
+    if (!Array.isArray(value) || value.length === 0)
+        fail('CONTEXT_BOUNDARY_INVALID', 409, 'A tool batch must contain calls.');
+    return value.map((entry) => {
+        if (typeof entry !== 'object' || entry === null || !('id' in entry) || typeof entry.id !== 'string' || entry.id.length === 0 || !('name' in entry) || typeof entry.name !== 'string' || entry.name.length === 0 || !('arguments' in entry)) {
+            fail('CONTEXT_BOUNDARY_INVALID', 409, 'Invalid tool call identity or arguments.');
+        }
+        return { id: entry.id, name: entry.name, arguments: entry.arguments };
+    });
+}
+/** Included results without native tool identity are evidence, not protocol responses. */
+export function boundaryMessages(items) {
+    return items.map((item) => {
+        if (typeof item.id !== 'string' || typeof item.content !== 'string')
+            fail('CONTEXT_BOUNDARY_INVALID', 409, 'Invalid Context item identity or content.');
+        const base = { contextItemId: item.id, content: item.content };
+        if (item.kind === 'tool_calls')
+            return { ...base, role: 'assistant', toolCalls: contextToolCalls(base.content) };
+        if (item.kind === 'result' && typeof item.tool_call_id === 'string' && typeof item.tool_name === 'string') {
+            return { ...base, role: 'tool', toolCallId: item.tool_call_id, toolName: item.tool_name };
+        }
+        return { ...base, role: item.role === 'assistant' || item.role === 'system' ? item.role : 'user' };
+    });
+}

package/dist/core/context.d.ts

@@ -0,0 +1,3 @@
+import type { Document } from '../store/store.js';
+/** Full history remains stored; only the latest checkpoint and live tail are active. */
+export declare function activeContextItems(items: readonly Document[]): readonly Document[];

package/dist/core/context.js

@@ -0,0 +1,11 @@
+/** Full history remains stored; only the latest checkpoint and live tail are active. */
+export function activeContextItems(items) {
+    const visible = items.filter((item) => item.visible === true);
+    const checkpoint = visible.findLast((item) => item.kind === 'compaction' && item.locked !== true);
+    const prefixes = visible.filter((item) => item.role === 'system' && item.kind === 'message');
+    return [
+        ...prefixes,
+        ...(checkpoint === undefined ? [] : [checkpoint]),
+        ...visible.filter((item) => item.locked !== true && item.kind !== 'compaction' && !prefixes.includes(item))
+    ];
+}

package/dist/core/host.js

@@ -10,15 +10,18 @@ import { EventBus } from '../runtime/events.js';
 import { Scheduler } from '../runtime/scheduler.js';
 import { ArtifactStore } from '../runtime/artifacts.js';
 import { AiModelGateway } from '../runtime/model.js';
+import { ModelAuditLog } from '../runtime/model-audit.js';
+import { TaskAuditReader } from '../runtime/task-audit.js';
 import { AutoReviewer } from '../runtime/review.js';
 import { ProjectRuntimes } from '../runtime/projects.js';
 import { Observability } from '../runtime/observability.js';
 import { adapterTarget, assertManifestSet, coreManifests } from '../runtime/manifests.js';
-import { ExecutorClient, executorCapabilities } from '../adapters/executor.js';
+import { ExecutorClient } from '../adapters/executor.js';
+import { ExecutorRouter } from '../adapters/executor-router.js';
 import { mcpCapabilities } from '../adapters/mcp.js';
 import { LspPool, lspCapabilities } from '../adapters/lsp.js';
 import { revertCapabilities } from '../adapters/revert.js';
-import { applyPurge } from '../runtime/cleanup.js';
+import { applyPurge, commitPurge } from '../runtime/cleanup.js';
 import { createServer } from '../http/server.js';
 export async function launchCore(options = {}) {
     const root = resolve(options.installRoot ?? process.cwd());
@@ -26,189 +29,273 @@ export async function launchCore(options = {}) {
     await config.load();
     const target = adapterTarget(options.runtime ?? 'node');
     assertManifestSet(coreManifests(config.current.config), target);
-    const blockers = new Set();
-    const observability = new Observability(root, config.current.config.observability);
-    const events = new EventBus(id('instance'), config.current.config.sse, () => config.current.metadataRevision + pair.metadataRevision);
-    const pair = new PairStore(root, config.current.config.pairPath ?? 'config/pair.json', (clientId) => events.revoke(clientId));
+    const rollback = [];
     try {
-        await pair.load();
-    }
-    catch (error) {
-        blockers.add('pair');
-        observability.record('access', 'pair_load', 'failed', 0, { error_code: errorCode(error) });
-    }
-    const eventLogConfig = config.current.config.persistence?.eventLog;
-    const eventLog = eventLogConfig?.enabled === true ? new EventLog(root, eventLogConfig.path, eventLogConfig.fsync) : undefined;
-    await eventLog?.load();
-    const store = new Store(openDatabase(root, config.current.config.database.path), events, eventLog);
-    const interrupted = store.recover();
-    if (interrupted.length > 0)
-        observability.record('store', 'recovery', 'success', 0, { interrupted: interrupted.length });
-    // Not `root`. The app root is where config/lens.jsonc holds the Provider API keys and where
-    // config/pair.json holds the client allowlist, so making it the default Workspace put both inside
-    // the one directory an Agent's file Capabilities are allowed to reach: `read_file` would reach the
-    // credentials, and `write_file` on the pair file would let an Agent mark its own client verified.
-    // A dedicated subdirectory keeps a working default without making the containment boundary and the
-    // secret store the same path.
-    const defaultWorkspace = resolve(root, 'workspace');
-    await mkdir(defaultWorkspace, { recursive: true });
-    const defaultProject = store.defaultProject() ?? store.createProject('Project', [defaultWorkspace]);
-    const defaultProjectId = string(defaultProject.id);
-    const executor = await ExecutorClient.create(root, config);
-    try {
-        await executor.health();
-    }
-    catch (error) {
-        blockers.add('executor');
-        observability.record('executor', 'health', 'failed', 0, { error_code: errorCode(error) });
-    }
-    const scheduler = new Scheduler(config.current.config.concurrency);
-    const artifacts = new ArtifactStore(root, config.current.config.artifacts.directory, store, config.current.config.persistence?.contentStore?.mode ?? 'filesystem');
-    const models = new AiModelGateway(config, target);
-    const reviewer = new AutoReviewer(models, config);
-    const lsp = new LspPool(config.current.config.lspServers ?? {});
-    const sharedCapabilities = [
-        ...executorCapabilities(executor),
-        ...lspCapabilities(config.current.config.lspServers ?? {}, lsp),
-        ...revertCapabilities(store, executor)
-    ];
-    // An MCP server that cannot be reached loses its own tools and nothing else. It used to add a
-    // startup blocker, which put the whole runtime into health_only: one unreachable optional
-    // integration returned 503 from readiness and no client could sync. 02A also fixes the readiness
-    // blocker codes at PAIR_FILE_INVALID, MIGRATION_FAILED, RECOVERY_INCOMPLETE and STORE_UNAVAILABLE,
-    // so `mcp:<id>` was never a documented reason to be unready.
-    const degradedMcpServers = [];
-    for (const [serverId, serverConfig] of Object.entries(config.current.config.mcpServers ?? {})) {
+        const blockers = new Set();
+        const observability = new Observability(root, config.current.config.observability);
+        rollback.push(() => observability.close());
+        const events = new EventBus(id('instance'), config.current.config.sse, () => config.current.metadataRevision + pair.metadataRevision);
+        rollback.push(() => events.close());
+        const pair = new PairStore(root, config.current.config.pairPath ?? 'config/pair.json', (clientId) => events.revoke(clientId));
+        rollback.push(() => pair.close(), () => config.close());
         try {
-            sharedCapabilities.push(...await mcpCapabilities(serverId, serverConfig));
+            await pair.load();
         }
         catch (error) {
-            degradedMcpServers.push(serverId);
-            observability.record('mcp', 'discover', 'failed', 0, { server_id: serverId, error_code: errorCode(error) });
+            blockers.add('pair');
+            observability.record('access', 'pair_load', 'failed', 0, { error_code: errorCode(error) });
         }
-    }
-    const runtimes = new ProjectRuntimes(store, config, scheduler, artifacts, models, reviewer, sharedCapabilities, target, events, defaultProjectId);
-    runtimes.get(defaultProjectId);
-    runtimes.startIdleEviction();
-    // Graceful stop arrives as a request on the Server's control path, not as an OS signal, so the
-    // runtime needs a way to hand that request outwards. The Promise is created before the Server so
-    // the Route can never fire into an unset resolver.
-    let signalShutdown = () => undefined;
-    const shutdownRequested = new Promise((resolve) => { signalShutdown = resolve; });
-    const https = await httpsOptions(root, config);
-    const server = createServer({
-        ...(https === undefined ? {} : { https }),
-        config,
-        pair,
-        store,
-        events,
-        runtime: (projectId) => runtimes.get(projectId),
-        refreshProject: (projectId) => runtimes.refresh(projectId),
-        models,
-        artifacts,
-        observability,
-        executor,
-        defaultProjectId,
-        ready: () => ({ mode: blockers.size === 0 ? 'full' : 'health_only', blockers: [...blockers] }),
-        requestShutdown: () => { signalShutdown(); }
-    });
-    await server.listen({ ...config.current.config.listen });
-    for (const serverId of degradedMcpServers) {
-        events.emit(defaultProjectId, store.stateRevision(), 'runtime.notice', {
-            code: 'mcp_server_unavailable',
-            server_id: serverId
+        const eventLogConfig = config.current.config.persistence?.eventLog;
+        const eventLog = eventLogConfig?.enabled === true ? new EventLog(root, eventLogConfig.path, eventLogConfig.fsync) : undefined;
+        if (eventLog !== undefined)
+            rollback.push(() => eventLog.close());
+        await eventLog?.load();
+        const database = openDatabase(root, config.current.config.database.path);
+        rollback.push(() => { if (database.open)
+            database.close(); });
+        const store = new Store(database, events, eventLog, observability);
+        const interrupted = store.recover();
+        if (interrupted.length > 0)
+            observability.record('store', 'recovery', 'success', 0, { interrupted: interrupted.length });
+        // Not `root`. The app root is where config/lens.jsonc holds the Provider API keys and where
+        // config/pair.json holds the client allowlist, so making it the default Workspace put both inside
+        // the one directory an Agent's file Capabilities are allowed to reach: `read_file` would reach the
+        // credentials, and `edit_file` on the pair file would let an Agent mark its own client verified.
+        // A dedicated subdirectory keeps a working default without making the containment boundary and the
+        // secret store the same path.
+        const defaultWorkspace = resolve(root, 'workspace');
+        await mkdir(defaultWorkspace, { recursive: true });
+        const defaultProject = store.defaultProject() ?? store.createProject('Project', [defaultWorkspace]);
+        const defaultProjectId = string(defaultProject.id);
+        const executor = await ExecutorClient.create(root, config);
+        rollback.push(() => executor.close());
+        const localConfig = config.current.config.localExecutor;
+        if (localConfig && !/^(localhost|127\.0\.0\.1|\[::1\]):\d+$/u.test(localConfig.address))
+            throw new Error('localExecutor must use a loopback address.');
+        const localExecutor = localConfig ? await ExecutorClient.create(root, config, { ...localConfig, sharedFilesystem: true }) : undefined;
+        if (localExecutor)
+            rollback.push(() => localExecutor.close());
+        const additionalExecutors = new Map();
+        for (const [id, endpoint] of Object.entries(config.current.config.executors ?? {})) {
+            const client = await ExecutorClient.create(root, config, endpoint);
+            rollback.push(() => client.close());
+            additionalExecutors.set(id, client);
+        }
+        const executorRouter = new ExecutorRouter(store, executor, localExecutor, additionalExecutors);
+        try {
+            await executor.health();
+            await localExecutor?.health();
+        }
+        catch (error) {
+            blockers.add('executor');
+            observability.record('executor', 'health', 'failed', 0, { error_code: errorCode(error) });
+        }
+        const scheduler = new Scheduler(config.current.config.concurrency);
+        rollback.push(() => scheduler.close());
+        const artifacts = new ArtifactStore(root, config.current.config.artifacts.directory, store, config.current.config.persistence?.contentStore?.mode ?? 'filesystem');
+        const modelAudit = new ModelAuditLog(resolve(root, 'audit', `${id('model-audit')}.jsonl`));
+        const models = new AiModelGateway(config, target, artifacts, modelAudit);
+        const reviewer = new AutoReviewer(models, config);
+        if (config.current.config.executor.sharedFilesystem === true) {
+            let cursor;
+            do {
+                const page = store.listProjects({ ...(cursor === undefined ? {} : { cursor }), limit: 500 }, 'all');
+                for (const project of page.items) {
+                    try {
+                        await executor.verifySharedPaths(store.listWorkspaces(string(project.id)).filter(workspace => workspace.executor_id === 'remote').flatMap(workspace => Array.isArray(workspace.paths) ? workspace.paths.filter((path) => typeof path === 'string') : []));
+                    }
+                    catch {
+                        observability.record('executor', 'shared_workspace', 'failed', 0, { error_code: 'SHARED_WORKSPACE_REQUIRED' });
+                    }
+                }
+                cursor = page.nextCursor ?? undefined;
+            } while (cursor !== undefined);
+        }
+        const lsp = new LspPool(config.current.config.lspServers ?? {}, async (paths) => {
+            if (config.current.config.executor.sharedFilesystem !== true)
+                throw new Error('Local LSP requires executor.sharedFilesystem and a verified shared Workspace.');
+            await executor.verifySharedPaths(paths);
         });
-    }
-    pair.start((error) => {
-        observability.record('access', 'pair_reload', 'failed', 0, { error_code: errorCode(error) });
-        events.emit(defaultProjectId, store.stateRevision(), 'config.changed', { component: 'pair', error: error.message });
-    });
-    config.start((snapshot) => {
-        scheduler.updateLimits(snapshot.config.concurrency);
-        events.updateLimits(snapshot.config.sse);
-        events.emit(defaultProjectId, store.stateRevision(), 'config.changed', {
-            config_digest: snapshot.digest,
-            file_digest: snapshot.fileDigest,
-            pending_restart: snapshot.pendingRestart,
-            error: snapshot.error
+        rollback.push(() => lsp.close());
+        const sharedCapabilities = [
+            ...executorRouter.capabilities(),
+            ...lspCapabilities(config.current.config.lspServers ?? {}, lsp),
+            ...revertCapabilities(store, executorRouter)
+        ];
+        // An MCP server that cannot be reached loses its own tools and nothing else. It used to add a
+        // startup blocker, which put the whole runtime into health_only: one unreachable optional
+        // integration returned 503 from readiness and no client could sync. 02A also fixes the readiness
+        // blocker codes at PAIR_FILE_INVALID, MIGRATION_FAILED, RECOVERY_INCOMPLETE and STORE_UNAVAILABLE,
+        // so `mcp:<id>` was never a documented reason to be unready.
+        const degradedMcpServers = [];
+        for (const [serverId, serverConfig] of Object.entries(config.current.config.mcpServers ?? {})) {
+            try {
+                sharedCapabilities.push(...await mcpCapabilities(serverId, serverConfig));
+            }
+            catch (error) {
+                degradedMcpServers.push(serverId);
+                observability.record('mcp', 'discover', 'failed', 0, { server_id: serverId, error_code: errorCode(error) });
+            }
+        }
+        if (localExecutor) {
+            let cursor;
+            do {
+                const page = store.listProjects({ ...(cursor === undefined ? {} : { cursor }), limit: 500 }, 'all');
+                for (const project of page.items) {
+                    const paths = store.listWorkspaces(string(project.id)).filter(workspace => workspace.executor_id === 'local').flatMap(workspace => Array.isArray(workspace.paths) ? workspace.paths.filter((path) => typeof path === 'string') : []);
+                    try {
+                        await localExecutor.verifySharedPaths(paths);
+                    }
+                    catch {
+                        observability.record('executor', 'local_shared_workspace', 'failed', 0, { error_code: 'SHARED_WORKSPACE_REQUIRED' });
+                    }
+                }
+                cursor = page.nextCursor ?? undefined;
+            } while (cursor !== undefined);
+        }
+        for (const [executorId, client] of additionalExecutors) {
+            if (client.endpoint.sharedFilesystem !== true)
+                continue;
+            let cursor;
+            do {
+                const page = store.listProjects({ ...(cursor === undefined ? {} : { cursor }), limit: 500 }, 'all');
+                for (const project of page.items) {
+                    const paths = store.listWorkspaces(string(project.id)).filter(workspace => workspace.executor_id === executorId).flatMap(workspace => Array.isArray(workspace.paths) ? workspace.paths.filter((path) => typeof path === 'string') : []);
+                    try {
+                        await client.verifySharedPaths(paths);
+                    }
+                    catch {
+                        observability.record('executor', 'shared_workspace', 'failed', 0, { error_code: 'SHARED_WORKSPACE_REQUIRED', executor_id: executorId });
+                    }
+                }
+                cursor = page.nextCursor ?? undefined;
+            } while (cursor !== undefined);
+        }
+        const runtimes = new ProjectRuntimes(store, config, scheduler, artifacts, models, reviewer, sharedCapabilities, target, events, defaultProjectId, (path, executorId) => executorRouter.endpoint(executorId ?? 'remote').sharedWorkspace(path));
+        rollback.push(() => runtimes.close());
+        runtimes.get(defaultProjectId);
+        runtimes.startIdleEviction();
+        // Graceful stop arrives as a request on the Server's control path, not as an OS signal, so the
+        // runtime needs a way to hand that request outwards. The Promise is created before the Server so
+        // the Route can never fire into an unset resolver.
+        let signalShutdown = () => undefined;
+        const shutdownRequested = new Promise((resolve) => { signalShutdown = resolve; });
+        const https = await httpsOptions(root, config);
+        const server = createServer({
+            ...(https === undefined ? {} : { https }),
+            config,
+            pair,
+            store,
+            events,
+            runtime: (projectId) => runtimes.get(projectId),
+            refreshProject: (projectId) => runtimes.refresh(projectId),
+            models,
+            taskAudit: new TaskAuditReader(resolve(root, 'audit')),
+            artifacts,
+            observability,
+            executor,
+            executorRouter,
+            ...(localExecutor ? { localExecutor } : {}),
+            defaultProjectId,
+            ready: () => {
+                const current = [...blockers, ...(eventLog?.failed === true ? ['event_log'] : [])];
+                return { mode: current.length === 0 ? 'full' : 'health_only', blockers: current };
+            },
+            requestShutdown: () => { signalShutdown(); }
         });
-    });
-    const maintenanceTimer = setInterval(() => {
-        void runRetention(store, artifacts, executor, config).catch((error) => {
-            observability.record('maintenance', 'retention', 'failed', 0, { error_code: errorCode(error) });
+        rollback.push(() => server.close());
+        await server.listen({ ...config.current.config.listen });
+        for (const serverId of degradedMcpServers) {
+            events.emit(defaultProjectId, store.stateRevision(), 'runtime.notice', {
+                code: 'mcp_server_unavailable',
+                server_id: serverId
+            });
+        }
+        pair.start((error) => {
+            blockers.add('pair');
+            observability.record('access', 'pair_reload', 'failed', 0, { error_code: errorCode(error) });
+            events.emit(defaultProjectId, store.stateRevision(), 'config.changed', { component: 'pair', error: error.message });
+        }, () => { blockers.delete('pair'); });
+        config.start((snapshot) => {
+            observability.record('config', 'reload', snapshot.error === null ? 'success' : 'failed', 0, { error_code: snapshot.error === null ? null : 'CONFIG_INVALID' });
+            scheduler.updateLimits(snapshot.config.concurrency);
+            events.updateLimits(snapshot.config.sse);
+            events.emit(defaultProjectId, store.stateRevision(), 'config.changed', {
+                config_digest: snapshot.digest,
+                file_digest: snapshot.fileDigest,
+                pending_restart: snapshot.pendingRestart,
+                error: snapshot.error
+            });
         });
-    }, 60 * 60 * 1000);
-    maintenanceTimer.unref();
-    let closing;
-    return {
-        url: `${config.current.config.tls.enabled ? 'https' : 'http'}://${config.current.config.listen.host}:${config.current.config.listen.port}`,
-        shutdownRequested,
-        close: () => {
-            if (closing !== undefined)
+        const maintenanceTimer = setInterval(() => {
+            void runRetention(store, artifacts, executorRouter, config).catch((error) => {
+                observability.record('maintenance', 'retention', 'failed', 0, { error_code: errorCode(error) });
+            });
+        }, 60 * 60 * 1000);
+        maintenanceTimer.unref();
+        rollback.push(() => clearInterval(maintenanceTimer));
+        let closing;
+        return {
+            url: `${config.current.config.tls.enabled ? 'https' : 'http'}://${config.current.config.listen.host}:${config.current.config.listen.port}`,
+            shutdownRequested,
+            close: () => {
+                if (closing !== undefined)
+                    return closing;
+                const serverClosing = server.close();
+                void serverClosing.catch(() => undefined);
+                closing = closeResources([
+                    () => { clearInterval(maintenanceTimer); config.close(); pair.close(); },
+                    () => runtimes.close(),
+                    () => scheduler.close(),
+                    () => events.close(),
+                    () => lsp.close(),
+                    () => executor.close(),
+                    () => localExecutor?.close(),
+                    ...[...additionalExecutors.values()].map(client => () => client.close()),
+                    () => serverClosing,
+                    () => store.close(),
+                    () => observability.close()
+                ], config.current.config.shutdown?.graceMs ?? 30_000).catch((error) => {
+                    server.server.closeAllConnections();
+                    throw error;
+                });
                 return closing;
-            closing = (async () => {
-                const graceMs = config.current.config.shutdown?.graceMs ?? 30_000;
-                const ordered = (async () => {
-                    const serverClosing = server.close();
-                    clearInterval(maintenanceTimer);
-                    config.close();
-                    pair.close();
-                    await runtimes.close();
-                    scheduler.close();
-                    events.close();
-                    await lsp.close();
-                    executor.close();
-                    await serverClosing;
-                    await observability.close();
-                    await store.close();
-                })();
-                // Bounded, because an unbounded wait here is worse than an imperfect stop. A stage that
-                // never settles -- a Worker ignoring cancellation, an LSP child not exiting -- would strand
-                // the process with no way out but a hard kill, and a hard kill discards this whole ordered
-                // sequence. Section 10 already leaves unconfirmable objects to Recovery and SQLite/WAL is
-                // crash-safe, so returning after the grace period loses no committed state.
-                await withinGrace(ordered, graceMs, observability);
-            })();
-            return closing;
-        }
-    };
-}
-/**
- * Waits for the ordered shutdown, but not forever.
- *
- * The diagnostic is recorded the moment the grace period expires rather than afterwards, because
- * `observability.close()` is itself one of the last stages: recording later could be writing to a
- * sink that the sequence has already closed.
- */
-async function withinGrace(ordered, graceMs, observability) {
-    let timer;
-    const expired = new Promise((resolve) => {
-        timer = setTimeout(() => {
-            try {
-                observability.record('runtime', 'shutdown', 'failed', graceMs, { reason: 'grace_expired', grace_ms: graceMs });
-            }
-            catch {
-                // A sink that is already gone must not turn a slow stop into a crash.
             }
-            resolve('expired');
-        }, graceMs);
-        // Never the reason the process stays alive.
-        timer.unref();
-    });
-    // Settled either way, so a stage that rejects after the grace period cannot surface as an
-    // unhandled rejection once nothing is awaiting it any more.
-    const settled = ordered.then(() => 'closed', (error) => {
+        };
+    }
+    catch (error) {
         try {
-            observability.record('runtime', 'shutdown', 'failed', 0, { error_code: errorCode(error) });
+            await closeResources(rollback.reverse(), config.current.config.shutdown?.graceMs ?? 30_000);
         }
-        catch {
-            // As above.
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], 'Core startup failed and cleanup was incomplete.', { cause: error });
         }
-        return 'failed';
-    });
-    await Promise.race([settled, expired]);
-    if (timer !== undefined)
-        clearTimeout(timer);
+        throw error;
+    }
+}
+async function closeResources(actions, graceMs) {
+    const deadline = Date.now() + graceMs;
+    const failures = [];
+    for (const action of actions) {
+        let timer;
+        try {
+            await Promise.race([
+                Promise.resolve().then(action),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('Core shutdown grace period expired.')), Math.max(0, deadline - Date.now()));
+                })
+            ]);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
+    if (failures.length > 0)
+        throw new AggregateError(failures, 'Core cleanup failed or timed out.');
 }
 async function runRetention(store, artifacts, executor, config) {
     const retention = config.current.config.historyRetention;
@@ -226,7 +313,8 @@ async function runRetention(store, artifacts, executor, config) {
         cursor = page.nextCursor ?? undefined;
     } while (cursor !== undefined);
     for (const projectId of projectIds) {
-        await applyPurge(store.purgeArchived(projectId, before), artifacts, executor);
+        await commitPurge(executor, stateId => store.purgeArchived(projectId, before, stateId));
+        await applyPurge(projectId, store, artifacts, executor);
     }
 }
 async function httpsOptions(root, config) {

package/dist/entry/pair.d.ts

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

package/dist/entry/pair.js

@@ -0,0 +1,14 @@
+import { parseArgs } from 'node:util';
+import { ConfigRuntime } from '../config/runtime.js';
+import { PairStore } from '../core/access.js';
+const args = process.argv.slice(2);
+if (args[0] === '--')
+    args.shift();
+const { values } = parseArgs({ args, options: { client: { type: 'string' }, config: { type: 'string' }, 'strong-trust': { type: 'boolean', default: false } } });
+if (!values.client)
+    throw new Error('Supply --client with the identity shown by the client after its first connection.');
+const config = new ConfigRuntime(process.cwd(), values.config);
+await config.load();
+const pair = new PairStore(process.cwd(), config.current.config.pairPath ?? 'config/pair.json', () => { });
+await pair.load();
+process.stdout.write(`${await pair.issueCredential(values.client, values['strong-trust'])}\n`);

package/dist/entry/run.js

@@ -11,7 +11,7 @@ function listenForShutdown(server) {
         if (closing)
             return;
         closing = true;
-        void server.close().finally(() => process.exit(0));
+        void server.close().then(() => process.exit(0), () => process.exit(1));
     };
     // The graceful stop a process manager is expected to use: a request on the Server's control
     // path, not a signal. The signal handlers stay for an interactive terminal and for anything that