@orion-agents/orion-code 0.1.8 → 0.2.0

package/dist/runtime/orion-runtime-v1.js

@@ -0,0 +1,958 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrionRuntimeV1 = exports.OrionRuntimeV1Error = void 0;
+exports.createOrionRuntimeV1 = createOrionRuntimeV1;
+const path_1 = require("path");
+const agent_loop_1 = require("./agent-loop");
+const batch_read_service_1 = require("./batch-read-service");
+const capability_receipt_journal_1 = require("./capability-receipt-journal");
+const capability_step_factory_1 = require("./capability-step-factory");
+const first_party_tool_services_1 = require("./first-party-tool-services");
+const goal_runtime_coordinator_1 = require("./goal-runtime-coordinator");
+const mcp_1 = require("./mcp");
+const prompts_1 = require("./prompts");
+const canonical_1 = require("./protocol/canonical");
+const harness_metrics_1 = require("./harness-metrics");
+const resource_scope_1 = require("./resource-scope");
+const runtime_services_1 = require("./runtime-services");
+const skills_1 = require("./skills");
+const step_snapshot_1 = require("./step-snapshot");
+const thread_compact_persistence_1 = require("./thread-compact-persistence");
+const task_context_service_1 = require("./task-context-service");
+const thread_event_store_1 = require("./thread-event-store");
+const thread_runtime_1 = require("./thread-runtime");
+const thread_tool_journal_1 = require("./thread-tool-journal");
+const tool_gateway_1 = require("./tool-gateway");
+const turn_commit_1 = require("./turn-commit");
+class OrionRuntimeV1Error extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'OrionRuntimeV1Error';
+    }
+}
+exports.OrionRuntimeV1Error = OrionRuntimeV1Error;
+const SERVICE_IDS = Object.freeze({
+    models: 'model-executor-v1',
+    threads: 'thread-runtime-v1',
+    policy: 'turn-routed-first-party-tool-policy-v1',
+    execution: 'execution-service-v1',
+    tools: 'tool-gateway-v1',
+    prompts: 'prompt-registry-v1',
+    skills: 'lazy-skill-runtime-v1',
+    mcp: 'lazy-mcp-runtime-v1',
+    goals: 'goal-runtime-v2',
+    taskContext: 'task-context',
+    capabilities: 'capability-step-factory-v1',
+    events: 'thread-event-store-v1',
+    compaction: 'compact-transaction-v1',
+});
+/** Process-local guard; it is an ownership check, never a service lookup path. */
+const ACTIVE_RUNTIME_OWNERS = new Map();
+/**
+ * Explicit first-party production composition root for exactly one ThreadRuntime.
+ * Construction is side-effect free; start() owns resources and close() releases them.
+ */
+class OrionRuntimeV1 {
+    constructor(options) {
+        this.stateValue = 'created';
+        this.closeRequested = false;
+        this.options = validateOptions(options);
+        this.ownerKey = ownerKey(this.options.eventStore);
+        this.scope = new resource_scope_1.ResourceScope({ deadlineMs: options.closeDeadlineMs });
+    }
+    get state() {
+        return this.stateValue;
+    }
+    get graph() {
+        return this.requireGraph();
+    }
+    get services() {
+        return this.requireGraph().services;
+    }
+    get contributors() {
+        return this.requireGraph().contributors;
+    }
+    get thread() {
+        return this.requireGraph().thread;
+    }
+    /** Safe control-plane projection. It never loads Skill bodies or connects MCP servers. */
+    diagnostics() {
+        const graph = this.requireGraph();
+        const projection = graph.thread.getProjection();
+        const admission = graph.thread.getAdmissionSnapshot();
+        const eventCursor = graph.eventStore.getCursor();
+        const recent = graph.eventStore.replay(Math.max(0, eventCursor - 256), 256).events;
+        const latestCapabilityEvent = [...recent]
+            .reverse()
+            .find(event => event.payload.type === 'capability.receipt');
+        const latestSnapshotEvent = [...recent]
+            .reverse()
+            .find(event => event.payload.type === 'step.snapshot');
+        const latestCommitEvent = [...recent]
+            .reverse()
+            .find(event => event.payload.type === 'turn.committed');
+        const latestCompactEvent = [...recent]
+            .reverse()
+            .find(event => event.payload.type.startsWith('compact.'));
+        const capability = parseCapabilityDiagnostics(latestCapabilityEvent, latestSnapshotEvent);
+        const latestCommit = latestCommitEvent?.payload.type === 'turn.committed'
+            ? (0, turn_commit_1.parseTurnCommitV1)(latestCommitEvent.payload.data.receipt)
+            : undefined;
+        const task = graph.taskContext.snapshot();
+        const activeTurn = projection.activeTurnId
+            ? projection.turns[projection.activeTurnId]
+            : undefined;
+        const serviceEntries = Object.entries(graph.services)
+            .map(([slot, service]) => ({ slot, serviceId: service.serviceId }))
+            .sort((left, right) => (left.slot < right.slot ? -1 : left.slot > right.slot ? 1 : 0));
+        const contributorEntries = Object.entries(graph.contributors).map(([lane, contributors]) => ({
+            lane,
+            ids: contributors.map(contributor => contributor.id),
+        }));
+        const criteria = task.state.contract?.criteria ?? [];
+        const evidenceRefs = (task.state.evidenceIndex ?? [])
+            .slice(-20)
+            .map(item => `${item.id}:${item.kind}:${item.verificationStatus ?? 'unknown'}`);
+        return Object.freeze({
+            version: 1,
+            runtime: {
+                state: this.stateValue,
+                services: serviceEntries,
+                contributors: contributorEntries,
+                scope: {
+                    id: graph.scope.id,
+                    state: graph.scope.state,
+                    epoch: graph.scope.epoch,
+                    activeResources: graph.scope.activeResourceCount,
+                    activeLeases: graph.scope.activeLeaseCount,
+                },
+            },
+            thread: {
+                threadId: projection.threadId,
+                status: projection.status,
+                cursor: projection.cursor,
+                projectionDigest: projection.digest,
+                projectionLag: Math.max(0, eventCursor - projection.cursor),
+                ...(projection.activeTurnId ? { activeTurnId: projection.activeTurnId } : {}),
+                activeItemIds: activeTurn
+                    ? activeTurn.itemIds.filter(itemId => projection.items[itemId]?.status === 'started')
+                    : [],
+                queuedTurns: admission.queue.length,
+                queuedBytes: admission.queuedBytes,
+                interruptRequested: Boolean(admission.activeTurn?.interruptIntentId),
+            },
+            taskContext: {
+                revision: task.revision,
+                taskEpoch: task.taskEpoch,
+                stateDigest: (0, canonical_1.digestRuntimeValue)(task.state),
+                criteria: criteria.length,
+                evidenceRefs,
+            },
+            ...(capability ? { capability } : {}),
+            skills: graph.skills.stats(),
+            mcp: graph.mcp.snapshot(),
+            latest: {
+                ...(latestCommit?.stopDecision
+                    ? { stopDecision: JSON.parse(latestCommit.stopDecision) }
+                    : {}),
+                ...(latestCompactEvent ? { compactEvent: latestCompactEvent.payload.type } : {}),
+                compactRecoveryDigest: graph.compactRecovery.digest,
+                eventCursor,
+            },
+        });
+    }
+    /**
+     * Apply Goal lifecycle control through an internal durable Thread turn.
+     * Status is a pure snapshot; every mutation receives its own TurnCommit.
+     */
+    async controlGoal(control) {
+        const graph = this.requireGraph();
+        if (control.action === 'status')
+            return graph.goal.control(control, 'status');
+        let resolveExecution;
+        let rejectExecution;
+        const execution = new Promise((resolvePromise, rejectPromise) => {
+            resolveExecution = resolvePromise;
+            rejectExecution = rejectPromise;
+        });
+        const admission = graph.thread.startGoalControl({
+            type: 'goal_control',
+            input: goalControlInput(control),
+            onRejected: reason => rejectExecution(new Error(`Goal control was rejected: ${reason}.`)),
+            run: async (context) => {
+                try {
+                    if (context.abortSignal.aborted)
+                        throw new Error('Goal control was interrupted.');
+                    const result = graph.goal.control(control, context.turnId, fields => {
+                        const previous = restoreLatestTurnCommit(graph.eventStore);
+                        const committed = graph.services.events.turnCommits.commit({
+                            turnId: context.turnId,
+                            history: previous ? parseCommittedHistory(previous) : [],
+                            taskContextState: graph.taskContext.exportState(),
+                            taskContextRevision: graph.taskContext.revision,
+                            terminal: { status: 'completed', outcome: `goal_control:${control.action}` },
+                            ...(fields.goalState ? { goalState: fields.goalState } : {}),
+                            ...(fields.stopDecision ? { stopDecision: fields.stopDecision } : {}),
+                        });
+                        return committed;
+                    });
+                    resolveExecution({ turnId: context.turnId, result });
+                    return { status: 'completed', outcome: `goal_control:${control.action}` };
+                }
+                catch (error) {
+                    rejectExecution(error);
+                    throw error;
+                }
+            },
+        });
+        if (admission.status === 'rejected') {
+            throw new Error(`Goal control was rejected: ${admission.reason}.`);
+        }
+        const deadlineTimer = admission.status === 'queued'
+            ? setTimeout(() => rejectExecution(new Error('Goal control was rejected: deadline_expired.')), Math.max(1, admission.deadline - Date.now()))
+            : undefined;
+        deadlineTimer?.unref();
+        let completed;
+        try {
+            completed = await execution;
+        }
+        finally {
+            if (deadlineTimer)
+                clearTimeout(deadlineTimer);
+        }
+        const terminal = await graph.thread.waitForTurnTerminal(completed.turnId);
+        if (terminal !== 'completed') {
+            throw new Error(`Goal control turn ended as ${terminal}.`);
+        }
+        return completed.result;
+    }
+    /** Schedule an explicit Compact transaction as a non-steerable maintenance turn. */
+    compact(input = {}) {
+        const graph = this.requireGraph();
+        const coordinator = this.options.loop?.compactCoordinator;
+        if (!coordinator) {
+            throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', 'Explicit compact requires a runtime-owned CompactCoordinator.');
+        }
+        const maxMessages = input.maxMessages ?? 20;
+        if (!Number.isSafeInteger(maxMessages) || maxMessages <= 0) {
+            throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', 'Explicit compact maxMessages must be a positive integer.');
+        }
+        const request = Object.freeze({
+            type: 'compact',
+            source: 'explicit',
+            prepare: async ({ source, history, }, signal) => {
+                throwIfAborted(signal);
+                const messages = parseModelVisibleHistory(history);
+                const result = await coordinator.compactManual(messages, maxMessages, input.focus);
+                throwIfAborted(signal);
+                return (0, thread_compact_persistence_1.createThreadCompactCandidateDraftV1)({
+                    source: 'explicit',
+                    sourceHistoryDigest: source.historyDigest,
+                    modelVisibleHistory: result.messages,
+                    payload: {
+                        version: 1,
+                        mode: 'explicit',
+                        summary: result.summary,
+                        summarySource: result.summarySource,
+                        summaryGeneratedAt: result.summaryGeneratedAt,
+                        fingerprint: result.fingerprint,
+                        beforeTokens: result.beforeTokens,
+                        afterTokens: result.afterTokens,
+                        plan: result.plan,
+                        semanticSummary: result.semanticSummary,
+                        diagnostics: result.diagnostics,
+                    },
+                });
+            },
+        });
+        return graph.thread.startCompactMaintenance(request, 'compact:explicit');
+    }
+    start() {
+        if (this.stateValue === 'started')
+            return Promise.resolve(this);
+        if (this.startFlight)
+            return this.startFlight;
+        if (this.stateValue === 'closing' || this.stateValue === 'closed') {
+            return Promise.reject(new OrionRuntimeV1Error('ORION_RUNTIME_CLOSED', 'Closed OrionRuntime cannot start.'));
+        }
+        this.stateValue = 'starting';
+        this.startFlight = this.performStart();
+        return this.startFlight;
+    }
+    close(reason = 'orion_runtime_closed') {
+        if (this.closeFlight)
+            return this.closeFlight;
+        this.closeRequested = true;
+        this.stateValue = 'closing';
+        this.closeFlight = this.performClose(reason);
+        return this.closeFlight;
+    }
+    async performStart() {
+        try {
+            this.acquireOwnership();
+            const eventStore = new thread_event_store_1.ThreadEventStore(this.options.eventStore.rootDir, this.options.eventStore.threadId, this.options.eventStore.options);
+            const compactPersistence = new thread_compact_persistence_1.ThreadCompactTransactionPersistenceV1(eventStore);
+            const compactRunner = new thread_compact_persistence_1.ThreadCompactMaintenanceRunnerV1(eventStore, this.options.compact);
+            const compactRecovery = await compactRunner.recoverOrphans();
+            const restored = restoreLatestTurnCommit(eventStore);
+            const taskContext = (0, task_context_service_1.createTaskContextService)(mergeTaskContextOptions(this.options.taskContext, restored));
+            const goal = new goal_runtime_coordinator_1.GoalRuntimeCoordinatorV2({
+                ...(this.options.goal ? { definition: this.options.goal } : {}),
+                ...(restored ? { restoredCommit: restored } : {}),
+            });
+            const prompts = new prompts_1.PromptRegistryV1();
+            const contributors = (0, runtime_services_1.createRuntimeContributors)(this.options.contributors ?? (0, runtime_services_1.emptyRuntimeContributorSlots)());
+            const skills = await this.scope.activate({
+                id: 'lazy-skills',
+                activate: () => {
+                    const runtime = new skills_1.LazySkillRuntime({
+                        ...this.options.skills,
+                        signal: this.scope.signal,
+                    });
+                    return { value: runtime, dispose: () => runtime.dispose() };
+                },
+            });
+            const mcp = await this.scope.activate({
+                id: 'lazy-mcp',
+                activate: () => {
+                    const runtime = new mcp_1.LazyMcpRuntime({ ...this.options.mcp, signal: this.scope.signal });
+                    return {
+                        value: runtime,
+                        dispose: context => runtime.dispose(context.reason),
+                    };
+                },
+            });
+            const basePolicy = new first_party_tool_services_1.FirstPartyToolPolicyServiceV1(this.options.toolCatalog, this.options.toolContext);
+            const subagentTurns = new Map();
+            const subagentTurnFlights = new Map();
+            const subagentUnavailableTurns = new Set();
+            const subagentPolicies = new Map();
+            const subagentAuthorityDigests = new Map();
+            const policy = Object.freeze({
+                serviceId: 'turn-routed-first-party-tool-policy-v1',
+                decide: (input) => {
+                    if (input.descriptor.name === 'subtask') {
+                        const turnPolicy = subagentPolicies.get(input.snapshot.turnId);
+                        if (!turnPolicy) {
+                            return Object.freeze({
+                                behavior: 'deny',
+                                source: 'subagent-turn',
+                                reason: 'No active turn-owned subagent policy exists for this snapshot.',
+                                digest: (0, canonical_1.digestRuntimeValue)({
+                                    behavior: 'deny',
+                                    source: 'subagent-turn',
+                                    reason: 'No active turn-owned subagent policy exists for this snapshot.',
+                                }),
+                            });
+                        }
+                        return turnPolicy.decide(input);
+                    }
+                    return basePolicy.decide(input);
+                },
+            });
+            const approval = new first_party_tool_services_1.FirstPartyToolApprovalServiceV1(this.options.approvalHandler);
+            const sandbox = new first_party_tool_services_1.FirstPartySandboxServiceV1();
+            const execution = new step_snapshot_1.ExecutionService();
+            const toolJournal = new thread_tool_journal_1.ThreadToolInvocationJournalV1(eventStore);
+            const gateway = new tool_gateway_1.ToolGateway({
+                policy,
+                approval,
+                sandbox,
+                execution,
+                nested: new batch_read_service_1.BatchReadExecutionServiceV1(),
+                journal: toolJournal,
+            });
+            const capabilityJournal = new capability_receipt_journal_1.CapabilityReceiptJournalV1(eventStore);
+            const subagents = this.options.subagents ?? Object.freeze({ serviceId: 'subagents-disabled-v1' });
+            const runtimeServicesDigest = (0, canonical_1.digestRuntimeValue)({
+                version: 1,
+                services: { ...SERVICE_IDS, subagents: subagents.serviceId },
+            });
+            const resolveSubagentTurn = async (input, authority) => {
+                if (!this.options.subagents)
+                    return undefined;
+                if (subagentUnavailableTurns.has(input.turnId))
+                    return undefined;
+                const existing = subagentTurns.get(input.turnId);
+                if (existing) {
+                    assertSubagentAuthorityStable(input.turnId, authority, subagentAuthorityDigests);
+                    return existing;
+                }
+                const pending = subagentTurnFlights.get(input.turnId);
+                if (pending)
+                    return pending;
+                const flight = Promise.resolve(this.options.subagents.createTurn({
+                    store: eventStore,
+                    threadId: input.threadId,
+                    turnId: input.turnId,
+                    input: input.input,
+                    mode: input.mode,
+                    authority,
+                    abortSignal: input.abortSignal,
+                    flush: () => undefined,
+                })).then(async (capability) => {
+                    if (!capability) {
+                        subagentUnavailableTurns.add(input.turnId);
+                        return undefined;
+                    }
+                    try {
+                        validateSubagentTurnCapability(input, capability);
+                        subagentTurns.set(input.turnId, capability);
+                        subagentPolicies.set(input.turnId, new first_party_tool_services_1.FirstPartyToolPolicyServiceV1(capability.catalog, this.options.toolContext));
+                        subagentAuthorityDigests.set(input.turnId, authority.digest);
+                        return capability;
+                    }
+                    catch (error) {
+                        await capability.close('subagent_turn_start_failed');
+                        throw error;
+                    }
+                });
+                subagentTurnFlights.set(input.turnId, flight);
+                try {
+                    return await flight;
+                }
+                finally {
+                    subagentTurnFlights.delete(input.turnId);
+                }
+            };
+            const preparedRegistries = new Map();
+            const preparationKey = (input) => `${input.turnId}:${input.requestIndex}`;
+            const stepFactory = new capability_step_factory_1.CapabilityAgentLoopStepFactoryV1({
+                resolveConfiguration: async (input) => {
+                    const configured = await this.options.resolveCapabilityConfiguration(input, Object.freeze({
+                        runtimeServicesDigest,
+                        toolCatalog: this.options.toolCatalog,
+                        taskContext,
+                        skills,
+                        mcp,
+                        mcpCatalog: mcp.getCatalog(),
+                        prompts,
+                    }));
+                    const subagentTurn = await resolveSubagentTurn(input, configured.compiler.authority);
+                    const dynamic = mergeDynamicTools(configured.dynamicTools, subagentTurn?.catalog);
+                    const registry = new Map(this.options.toolCatalog.bindings);
+                    for (const [bindingId, binding] of dynamic?.bindings ?? []) {
+                        if (registry.has(bindingId)) {
+                            throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', `Dynamic tool binding collides with ${bindingId}.`);
+                        }
+                        registry.set(bindingId, binding);
+                    }
+                    preparedRegistries.set(preparationKey(input), registry);
+                    return {
+                        ...configured,
+                        dynamicTools: undefined,
+                        compiler: {
+                            ...configured.compiler,
+                            tools: [...this.options.toolCatalog.candidates, ...(dynamic?.candidates ?? [])],
+                            runtimeServicesDigest,
+                            mcpCatalogDigest: mcp.getCatalog().digest,
+                        },
+                    };
+                },
+                resolveToolRegistry: input => {
+                    const key = preparationKey(input);
+                    const registry = preparedRegistries.get(key);
+                    preparedRegistries.delete(key);
+                    if (!registry) {
+                        throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', `No frozen tool registry exists for ${key}.`);
+                    }
+                    return registry;
+                },
+                onCaptured: async (bundle) => {
+                    const commit = capabilityJournal.commit(bundle);
+                    await subagentTurns.get(bundle.snapshot.turnId)?.publishCommitted(bundle, commit);
+                },
+            });
+            const turnCommits = new turn_commit_1.ThreadTurnCommitJournalV1(eventStore);
+            const agentLoop = new agent_loop_1.AgentLoopV1({
+                llm: this.options.modelExecutor,
+                taskContext,
+                steps: stepFactory,
+                gateway,
+                loadBaseMessages: context => loadRuntimeBaseMessages(compactPersistence, this.options.loadBaseMessages?.(eventStore, context, prompts, {
+                    taskContext,
+                    goal,
+                    skills,
+                    mcp,
+                })),
+                toolContext: () => this.options.toolContext,
+                streamCallbacks: this.options.loop?.streamCallbacks,
+                loopBudget: this.options.loop?.loopBudget,
+                compactCoordinator: this.options.loop?.compactCoordinator,
+                commitTurn: commit => {
+                    const prepared = this.options.loop?.prepareTurnCommit?.(commit);
+                    const committed = prepared?.stopDecision
+                        ? withStopDecision(commit, prepared.stopDecision)
+                        : commit;
+                    let durableCommit;
+                    goal.commitTurn(committed, fields => {
+                        durableCommit = turnCommits.commit({
+                            turnId: committed.turnId,
+                            history: committed.history,
+                            taskContextState: committed.taskContextState,
+                            taskContextRevision: committed.taskContextRevision,
+                            terminal: terminalFromAgentCommit(committed.queryComplete),
+                            ...(fields.goalState ? { goalState: fields.goalState } : {}),
+                            ...(fields.stopDecision ? { stopDecision: fields.stopDecision } : {}),
+                            ...(prepared?.plan ? { plan: prepared.plan } : {}),
+                        });
+                        return durableCommit;
+                    });
+                    if (!durableCommit) {
+                        throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', `Turn ${commit.turnId} completed without an authoritative TurnCommit.`);
+                    }
+                    try {
+                        const projected = this.options.loop?.onTurnCommitted?.(committed, durableCommit);
+                        return projected && typeof projected.then === 'function'
+                            ? projected.catch(() => undefined)
+                            : undefined;
+                    }
+                    catch {
+                        // UI/metrics projections cannot veto an already durable TurnCommit.
+                        return undefined;
+                    }
+                },
+            });
+            const thread = await this.scope.activate({
+                id: 'thread-runtime',
+                activate: () => {
+                    const runtime = new thread_runtime_1.ThreadRuntimeV1({
+                        ...this.options.thread,
+                        store: eventStore,
+                        runner: agentLoop,
+                        maintenanceRunner: compactRunner,
+                        projectPath: this.options.projectPath,
+                        requireTurnCommit: true,
+                        onTurnStarted: turn => {
+                            goal.markTurnStarted(turn.turnId, turn.startedAt);
+                            this.options.thread?.onTurnStarted?.(turn);
+                        },
+                        onTurnDurablyTerminal: terminal => goal.afterDurableTerminal(terminal.turnId, terminal.terminal) ??
+                            this.options.thread?.onTurnDurablyTerminal?.(terminal),
+                        onTurnSettled: async (turnId) => {
+                            for (const key of [...preparedRegistries.keys()]) {
+                                if (key.startsWith(`${turnId}:`))
+                                    preparedRegistries.delete(key);
+                            }
+                            const turnCapability = subagentTurns.get(turnId);
+                            subagentTurns.delete(turnId);
+                            subagentTurnFlights.delete(turnId);
+                            subagentUnavailableTurns.delete(turnId);
+                            subagentPolicies.delete(turnId);
+                            subagentAuthorityDigests.delete(turnId);
+                            try {
+                                await turnCapability?.close('parent_turn_settled');
+                            }
+                            finally {
+                                await mcp.releaseOwner(turnId);
+                                await this.options.thread?.onTurnSettled?.(turnId);
+                            }
+                        },
+                    });
+                    return {
+                        value: runtime,
+                        dispose: async (context) => {
+                            goal.close();
+                            runtime.close(context.reason);
+                            await runtime.waitForIdle();
+                        },
+                    };
+                },
+            });
+            const services = (0, runtime_services_1.createRuntimeServices)({
+                models: servicePort(SERVICE_IDS.models, { executor: this.options.modelExecutor }),
+                threads: servicePort(SERVICE_IDS.threads, { runtime: thread }),
+                policy,
+                execution: servicePort(SERVICE_IDS.execution, { execution }),
+                tools: servicePort(SERVICE_IDS.tools, {
+                    catalog: this.options.toolCatalog,
+                    gateway,
+                    approval,
+                    sandbox,
+                    journal: toolJournal,
+                }),
+                prompts: servicePort(SERVICE_IDS.prompts, { registry: prompts }),
+                skills: servicePort(SERVICE_IDS.skills, { runtime: skills }),
+                mcp: servicePort(SERVICE_IDS.mcp, { runtime: mcp }),
+                goals: servicePort(SERVICE_IDS.goals, { runtime: goal }),
+                taskContext,
+                capabilities: servicePort(SERVICE_IDS.capabilities, {
+                    steps: stepFactory,
+                    journal: capabilityJournal,
+                }),
+                events: servicePort(SERVICE_IDS.events, { store: eventStore, turnCommits }),
+                compaction: servicePort(SERVICE_IDS.compaction, {
+                    persistence: compactPersistence,
+                    runner: compactRunner,
+                    recovery: compactRecovery,
+                }),
+                subagents,
+            });
+            this.graphValue = Object.freeze({
+                services,
+                contributors,
+                scope: this.scope,
+                eventStore,
+                taskContext,
+                prompts,
+                skills,
+                mcp,
+                goal,
+                execution,
+                gateway,
+                capabilityJournal,
+                compactPersistence,
+                compactRunner,
+                compactRecovery,
+                stepFactory,
+                agentLoop,
+                thread,
+            });
+            const restoredTurn = restored
+                ? eventStore.loadProjection().turns[restored.turnId]
+                : undefined;
+            if (!this.closeRequested &&
+                restoredTurn?.status === 'completed' &&
+                eventStore.loadProjection().queue.length === 0) {
+                const continuation = goal.takeRestoredContinuation();
+                if (continuation)
+                    thread.startGoalContinuation(continuation);
+            }
+            if (this.closeRequested) {
+                throw new OrionRuntimeV1Error('ORION_RUNTIME_CLOSED', 'OrionRuntime was closed while starting.');
+            }
+            this.stateValue = 'started';
+            await this.options.loop?.onRuntimeStarted?.({
+                ...(restored ? { restoredCommit: restored } : {}),
+                thread,
+                eventStore,
+            });
+            return this;
+        }
+        catch (error) {
+            await this.scope.close({ reason: 'orion_runtime_start_failed' });
+            this.releaseOwnership();
+            this.stateValue = 'closed';
+            throw error;
+        }
+    }
+    async performClose(reason) {
+        if (this.startFlight) {
+            try {
+                await this.startFlight;
+            }
+            catch {
+                // Failed start already rolled back the same ResourceScope.
+            }
+        }
+        const report = await this.scope.close({ reason });
+        this.releaseOwnership();
+        this.stateValue = 'closed';
+        return report;
+    }
+    acquireOwnership() {
+        const existing = ACTIVE_RUNTIME_OWNERS.get(this.ownerKey);
+        if (existing && existing !== this) {
+            throw new OrionRuntimeV1Error('ORION_RUNTIME_OWNER_CONFLICT', `Thread ${this.options.eventStore.threadId} already has an active OrionRuntime owner.`);
+        }
+        ACTIVE_RUNTIME_OWNERS.set(this.ownerKey, this);
+    }
+    releaseOwnership() {
+        if (ACTIVE_RUNTIME_OWNERS.get(this.ownerKey) === this) {
+            ACTIVE_RUNTIME_OWNERS.delete(this.ownerKey);
+        }
+    }
+    requireGraph() {
+        if (!this.graphValue || this.stateValue !== 'started') {
+            throw new OrionRuntimeV1Error('ORION_RUNTIME_NOT_STARTED', 'OrionRuntime services are available only after start().');
+        }
+        return this.graphValue;
+    }
+}
+exports.OrionRuntimeV1 = OrionRuntimeV1;
+function createOrionRuntimeV1(options) {
+    return new OrionRuntimeV1(options);
+}
+function mergeDynamicTools(configured, subagentCatalog) {
+    if (!subagentCatalog)
+        return configured;
+    const candidates = [...(configured?.candidates ?? [])];
+    const bindings = new Map(configured?.bindings ?? []);
+    const candidateNames = new Set(candidates.map(candidate => candidate.descriptor.name));
+    const candidateBindingIds = new Set(candidates.map(candidate => candidate.bindingId));
+    for (const candidate of subagentCatalog.candidates) {
+        if (candidateNames.has(candidate.descriptor.name)) {
+            invalidConfiguration(`Turn subagent tool collides with dynamic tool ${candidate.descriptor.name}.`);
+        }
+        if (candidateBindingIds.has(candidate.bindingId) || bindings.has(candidate.bindingId)) {
+            invalidConfiguration(`Turn subagent binding collides with dynamic binding ${candidate.bindingId}.`);
+        }
+        candidates.push(candidate);
+        candidateNames.add(candidate.descriptor.name);
+        candidateBindingIds.add(candidate.bindingId);
+    }
+    for (const [bindingId, binding] of subagentCatalog.bindings) {
+        if (bindings.has(bindingId)) {
+            invalidConfiguration(`Turn subagent binding collides with dynamic binding ${bindingId}.`);
+        }
+        bindings.set(bindingId, binding);
+    }
+    return Object.freeze({ candidates: Object.freeze(candidates), bindings });
+}
+function validateSubagentTurnCapability(input, capability) {
+    const catalog = capability.catalog;
+    const candidate = catalog?.candidates[0];
+    const binding = candidate ? catalog.bindings.get(candidate.bindingId) : undefined;
+    if (!capability.serviceId?.trim() ||
+        capability.turnId !== input.turnId ||
+        typeof capability.publishCommitted !== 'function' ||
+        typeof capability.close !== 'function' ||
+        !catalog ||
+        catalog.entries.length !== 1 ||
+        catalog.candidates.length !== 1 ||
+        catalog.bindings.size !== 1 ||
+        candidate?.descriptor.name !== 'subtask' ||
+        candidate.descriptor.risk.readOnly !== true ||
+        candidate.descriptor.risk.destructive ||
+        !binding ||
+        binding.descriptor.executorId !== candidate.descriptor.executorId ||
+        binding.descriptor.schemaDigest !== candidate.descriptor.schemaDigest) {
+        invalidConfiguration(`Subagent turn ${input.turnId} must expose exactly one read-only exact subtask binding.`);
+    }
+}
+function assertSubagentAuthorityStable(turnId, authority, digests) {
+    const expected = digests.get(turnId);
+    if (expected && expected !== authority.digest) {
+        invalidConfiguration(`Subagent authority drifted within root turn ${turnId}.`);
+    }
+}
+function parseCapabilityDiagnostics(capabilityEvent, snapshotEvent) {
+    if (!capabilityEvent || capabilityEvent.payload.type !== 'capability.receipt') {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(capabilityEvent.payload.data.receipt);
+    }
+    catch {
+        invalidConfiguration('Durable CapabilityReceipt is not valid JSON.');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        invalidConfiguration('Durable CapabilityReceipt is not an object.');
+    }
+    const receipt = parsed;
+    const { digest, ...content } = receipt;
+    if (typeof digest !== 'string' ||
+        (0, canonical_1.digestRuntimeValue)(content) !== digest ||
+        digest !== capabilityEvent.payload.data.digest ||
+        receipt.threadId !== capabilityEvent.threadId ||
+        receipt.turnId !== capabilityEvent.turnId ||
+        receipt.stepId !== capabilityEvent.stepId ||
+        receipt.requestId !== capabilityEvent.payload.data.receiptId) {
+        invalidConfiguration('Durable CapabilityReceipt failed identity or integrity validation.');
+    }
+    let stepSnapshotDigest = 'unavailable';
+    if (snapshotEvent?.payload.type === 'step.snapshot' &&
+        snapshotEvent.threadId === receipt.threadId &&
+        snapshotEvent.turnId === receipt.turnId &&
+        snapshotEvent.stepId === receipt.stepId) {
+        stepSnapshotDigest = snapshotEvent.payload.data.digest;
+    }
+    const fullSchemaBytes = harness_metrics_1.CURRENT_TOOL_SCHEMA_BASELINE_V1.bytes;
+    const schemaReductionPercent = Number(((1 - receipt.toolSchemaBytes / fullSchemaBytes) * 100).toFixed(3));
+    return Object.freeze({
+        requestId: receipt.requestId,
+        stepId: receipt.stepId,
+        direct: [...receipt.directToolNames],
+        deferred: [...receipt.deferredToolNames],
+        hidden: { ...receipt.hiddenToolReasons },
+        omitted: receipt.omitted.map(item => ({ id: item.id, reason: item.reason })),
+        schemaBytes: receipt.toolSchemaBytes,
+        fullSchemaBytes,
+        schemaReductionPercent,
+        stepSnapshotDigest,
+        toolRouterDigest: receipt.toolRouterDigest,
+        authorityDigest: receipt.authorityDigest,
+        executionPolicyDigest: receipt.executionPolicyDigest,
+        skillCatalogDigest: receipt.skillCatalogDigest,
+        selectedSkillIds: [...receipt.selectedSkillIds],
+        mcpCatalogDigest: receipt.mcpCatalogDigest,
+        selectedMcpBindings: receipt.selectedMcpBindings.map(binding => `${binding.serverId}:${binding.toolName}`),
+        promptSections: receipt.promptManifest.map(section => ({
+            id: section.id,
+            digest: section.digest,
+            selected: section.selected,
+            ...(section.reason ? { reason: section.reason } : {}),
+        })),
+        receiptDigest: receipt.digest,
+    });
+}
+function validateOptions(options) {
+    if (!options || typeof options !== 'object')
+        invalidConfiguration('Options are required.');
+    if (!options.modelExecutor)
+        invalidConfiguration('modelExecutor is required.');
+    if (!options.toolCatalog)
+        invalidConfiguration('toolCatalog is required.');
+    if (!options.toolContext?.cwd?.trim())
+        invalidConfiguration('toolContext.cwd is required.');
+    if (!options.eventStore?.rootDir?.trim()) {
+        invalidConfiguration('eventStore.rootDir is required.');
+    }
+    if (!options.eventStore?.threadId?.trim()) {
+        invalidConfiguration('eventStore.threadId is required.');
+    }
+    if (!options.projectPath?.trim())
+        invalidConfiguration('projectPath is required.');
+    if (typeof options.resolveCapabilityConfiguration !== 'function') {
+        invalidConfiguration('resolveCapabilityConfiguration is required.');
+    }
+    if (!options.skills || !Array.isArray(options.skills.providers)) {
+        invalidConfiguration('skills.providers must be an array.');
+    }
+    if (!options.mcp || !Array.isArray(options.mcp.descriptors) || !options.mcp.connector) {
+        invalidConfiguration('MCP descriptors and connector are required.');
+    }
+    if (options.subagents &&
+        (!options.subagents.serviceId?.trim() || typeof options.subagents.createTurn !== 'function')) {
+        invalidConfiguration('subagents must provide a serviceId and createTurn factory.');
+    }
+    return Object.freeze({
+        ...options,
+        eventStore: Object.freeze({
+            ...options.eventStore,
+            rootDir: (0, path_1.resolve)(options.eventStore.rootDir),
+        }),
+        projectPath: (0, path_1.resolve)(options.projectPath),
+    });
+}
+function ownerKey(roots) {
+    return `${(0, path_1.resolve)(roots.rootDir)}\u0000${roots.threadId}`;
+}
+function goalControlInput(control) {
+    return `goal-control:${control.action}:${(0, canonical_1.digestRuntimeValue)(control)}`;
+}
+function parseCommittedHistory(commit) {
+    let parsed;
+    try {
+        parsed = JSON.parse(commit.history);
+    }
+    catch {
+        invalidConfiguration('Durable TurnCommit history is not valid JSON.');
+    }
+    if (!Array.isArray(parsed)) {
+        invalidConfiguration('Durable TurnCommit history is not an array.');
+    }
+    return parseModelVisibleHistory(parsed);
+}
+function mergeTaskContextOptions(configured, restored) {
+    if (!restored)
+        return configured;
+    const durableState = parseTaskContextState(restored);
+    if (configured.state &&
+        (0, canonical_1.digestRuntimeValue)(configured.state) !== (0, canonical_1.digestRuntimeValue)(durableState)) {
+        invalidConfiguration('Configured TaskContext state conflicts with the durable TurnCommit.');
+    }
+    if (configured.revision !== undefined && configured.revision !== restored.taskContextRevision) {
+        invalidConfiguration('Configured TaskContext revision conflicts with the durable TurnCommit.');
+    }
+    return {
+        ...configured,
+        state: durableState,
+        revision: restored.taskContextRevision,
+    };
+}
+function restoreLatestTurnCommit(store) {
+    const commits = Object.values(store.loadProjection().turns)
+        .map(turn => turn.commit)
+        .filter((commit) => Boolean(commit))
+        .sort((left, right) => left.seq - right.seq);
+    return commits.length > 0 ? (0, turn_commit_1.parseTurnCommitV1)(commits[commits.length - 1].receipt) : undefined;
+}
+function parseTaskContextState(commit) {
+    try {
+        return JSON.parse(commit.taskContext);
+    }
+    catch {
+        invalidConfiguration('Durable TurnCommit TaskContext is not valid JSON.');
+    }
+}
+async function loadRuntimeBaseMessages(compact, configured) {
+    const authoritative = compact.loadModelVisibleHistory();
+    const configuredMessages = configured ? await configured : undefined;
+    if (!authoritative)
+        return configuredMessages?.map(message => ({ ...message })) ?? [];
+    const durable = parseModelVisibleHistory(authoritative);
+    if (!configuredMessages)
+        return durable;
+    // Product loaders own current system/prompt assembly, but never the durable
+    // conversation tail. A committed Compact pointer replaces that tail here.
+    return [
+        ...configuredMessages
+            .filter(message => message.role === 'system')
+            .map(message => ({ ...message })),
+        ...durable.filter(message => message.role !== 'system').map(message => ({ ...message })),
+    ];
+}
+function parseModelVisibleHistory(history) {
+    if (!history.every(isMessage)) {
+        invalidConfiguration('Durable model-visible history has an invalid message shape.');
+    }
+    return history.map(message => ({ ...message }));
+}
+function isMessage(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const message = value;
+    return (['system', 'user', 'assistant', 'tool'].includes(message.role ?? '') &&
+        typeof message.content === 'string');
+}
+function throwIfAborted(signal) {
+    if (signal.aborted) {
+        throw signal.reason instanceof Error ? signal.reason : new Error('Compact was aborted.');
+    }
+}
+function withStopDecision(commit, stopDecision) {
+    const stats = commit.queryComplete.stats;
+    if (!stats)
+        invalidConfiguration('A prepared StopDecision requires terminal loop statistics.');
+    const queryComplete = {
+        ...commit.queryComplete,
+        stats: { ...stats, stopDecision },
+    };
+    const content = {
+        threadId: commit.threadId,
+        turnId: commit.turnId,
+        queryComplete,
+        taskContextState: commit.taskContextState,
+        taskContextRevision: commit.taskContextRevision,
+        ...(commit.taskContextCompletion
+            ? { taskContextCompletion: commit.taskContextCompletion }
+            : {}),
+        history: commit.history,
+    };
+    return Object.freeze({ ...content, digest: (0, canonical_1.digestRuntimeValue)(content) });
+}
+function terminalFromAgentCommit(complete) {
+    if (complete.stats?.finishReason === 'cancelled') {
+        return { status: 'interrupted', reason: complete.content || 'AgentLoop interrupted' };
+    }
+    if (complete.stats?.finishReason === 'failed') {
+        return { status: 'failed', error: complete.content || 'AgentLoop failed' };
+    }
+    return {
+        status: 'completed',
+        outcome: (0, canonical_1.canonicalRuntimeJson)({
+            finishReason: complete.stats?.finishReason ?? 'completed',
+            stopDecision: complete.stats?.stopDecision,
+        }),
+    };
+}
+function servicePort(serviceId, value) {
+    return Object.freeze({ serviceId, ...value });
+}
+function invalidConfiguration(message) {
+    throw new OrionRuntimeV1Error('ORION_RUNTIME_INVALID_CONFIGURATION', message);
+}
+//# sourceMappingURL=orion-runtime-v1.js.map