@orion-agents/orion-code 0.1.9 → 0.2.2

package/dist/runtime/subagents/production.js

@@ -1,28 +1,297 @@
 "use strict";
 /**
- * Production binding for {@link ExecuteChildQuery}.
+ * Modern production composition for isolated subagent Threads.
  *
- * Bridges the Supervisor (which is LLM-agnostic) to the real `query()` loop.
- * Each child gets its own {@link LLMService} so mutable per-request state
- * (`consecutive529Errors`, `usingFallback`, `lastRequestDiagnostics`) is not
- * shared across concurrent children. All children still flow through the shared
- * {@link SubagentProviderGate} for concurrency bounding and cooldown.
- *
- * `createLlm` and `runQuery` are injectable so the binding is unit-testable
- * without a live provider; production wires them to `new LLMService(...)` and
- * `query()`.
+ * This module deliberately does not import framework/query or the process-wide
+ * tool catalog. Every child receives an explicit model factory and immutable
+ * tool catalog, then runs through AgentLoopV1 -> ToolGateway -> ExecutionService.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductionSubagentRuntimeV1 = exports.ProductionSubagentRuntimeError = void 0;
 exports.createChildLlmConfig = createChildLlmConfig;
-exports.createProductionExecuteQuery = createProductionExecuteQuery;
-const llm_1 = require("../../services/llm");
-const query_1 = require("../../framework/query");
+exports.createProductionSubagentRuntimeV1 = createProductionSubagentRuntimeV1;
+const path_1 = require("path");
+const stop_decision_1 = require("../../framework/stop-decision");
+const agent_loop_1 = require("../agent-loop");
+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 canonical_1 = require("../protocol/canonical");
+const step_snapshot_1 = require("../step-snapshot");
+const subagent_thread_runtime_1 = require("../subagent-thread-runtime");
+const task_context_service_1 = require("../task-context-service");
+const thread_tool_journal_1 = require("../thread-tool-journal");
+const tool_gateway_1 = require("../tool-gateway");
+const turn_commit_1 = require("../turn-commit");
+const context_builder_1 = require("./context-builder");
+const child_executor_guard_1 = require("./child-executor-guard");
+const result_parser_1 = require("./result-parser");
+const receipt_journal_1 = require("./receipt-journal");
 const types_1 = require("./types");
-/**
- * Create a per-child LLMService. Children share the provider account but not
- * the mutable request state, so one child's fallback/retry does not reshape
- * another child's model choice or diagnostics.
- */
+class ProductionSubagentRuntimeError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ProductionSubagentRuntimeError';
+    }
+}
+exports.ProductionSubagentRuntimeError = ProductionSubagentRuntimeError;
+/** One root-turn-owned production service; child runtime instances are request scoped. */
+class ProductionSubagentRuntimeV1 {
+    constructor(options) {
+        this.serviceId = 'production-subagent-runtime-v1';
+        this.issuedModelExecutors = new WeakSet();
+        this.closed = false;
+        validateOptions(options);
+        this.options = Object.freeze({ ...options });
+        this.tree = new subagent_thread_runtime_1.SubagentThreadTreeScopeV1(options.treeLimits, options.parentAbortSignal);
+        this.receipts = new receipt_journal_1.SubagentReceiptJournalV1(options.receiptRootDir ?? (0, path_1.join)(options.childStoreRootDir, 'receipts'));
+        this.runtimeServicesDigest =
+            options.runtimeServicesDigest ??
+                (0, canonical_1.digestRuntimeValue)({
+                    version: 1,
+                    owner: this.serviceId,
+                    loop: 'agent-loop-v1',
+                    gateway: 'tool-gateway-v1',
+                    taskContext: 'task-context-v1',
+                    toolCatalog: options.toolCatalog.digest,
+                });
+    }
+    async execute(request) {
+        if (this.closed) {
+            throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_CLOSED', 'Production subagent runtime is closed.');
+        }
+        validateRequest(request);
+        this.bindParentTurn(request);
+        const deadline = createDeadline(request.abortSignal, request.timeoutMs);
+        const startedAt = Date.now();
+        const usage = createUsageAccumulator();
+        let persistedReceipt;
+        try {
+            const runtime = new subagent_thread_runtime_1.SubagentThreadRuntimeV1({
+                childStoreRootDir: this.options.childStoreRootDir,
+                tree: this.tree,
+                rolePolicies: this.options.rolePolicies,
+                defaultBudget: request.budget,
+                maxSummaryBytes: this.options.maxSummaryBytes ?? 64 * 1024,
+                createAgentLoop: input => this.createChildLoop(input, request, usage),
+                onReceipt: async (receipt) => {
+                    persistedReceipt = this.receipts.commit(receipt);
+                    await this.options.onReceipt?.(persistedReceipt);
+                },
+            });
+            const child = await runtime.run({
+                parent: request.parent,
+                parentAuthority: request.parentAuthority,
+                role: request.packet.role,
+                objective: request.packet.objective,
+                budget: request.budget,
+                abortSignal: deadline.signal,
+            });
+            if (!persistedReceipt || persistedReceipt.digest !== child.receipt.digest) {
+                throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', 'Child completed without a matching durable parent-facing receipt.');
+            }
+            const status = deadline.timedOut
+                ? 'timed_out'
+                : child.turnTerminal === 'interrupted' || child.status === 'cancelled'
+                    ? 'cancelled'
+                    : child.turnTerminal === 'failed' || child.status !== 'completed'
+                        ? 'failed'
+                        : 'completed';
+            const subtaskUsage = finalizeUsage(usage, child.usage, startedAt, true);
+            const result = (0, result_parser_1.parseSubtaskResult)({
+                id: request.taskId,
+                role: request.packet.role,
+                content: child.summary,
+                status,
+                usage: subtaskUsage,
+            });
+            result.stopDecision = child.stopDecision;
+            return Object.freeze({
+                result,
+                parentCancelled: status === 'cancelled' && Boolean(request.abortSignal?.aborted),
+                receipt: child.receipt,
+            });
+        }
+        catch (error) {
+            const status = deadline.timedOut
+                ? 'timed_out'
+                : request.abortSignal?.aborted || this.tree.signal.aborted
+                    ? 'cancelled'
+                    : 'failed';
+            const result = (0, result_parser_1.parseSubtaskResult)({
+                id: request.taskId,
+                role: request.packet.role,
+                content: errorMessage(error),
+                status,
+                usage: finalizeUsage(usage, undefined, startedAt, false),
+            });
+            result.stopDecision = (0, stop_decision_1.createStopDecision)({
+                scope: 'subagent',
+                status: status === 'cancelled' ? 'cancelled' : status === 'timed_out' ? 'stopped' : 'failed',
+                disposition: 'resume_allowed',
+                reason: { code: `subagent_${status}`, message: result.summary },
+                evidence: [],
+                nextActions: [
+                    { kind: 'retry', label: 'Inspect the child receipt boundary before retrying.' },
+                ],
+                resources: {
+                    llmRequests: {
+                        used: usage.providerAttempts,
+                        limit: request.budget.maxModelRequests,
+                    },
+                    toolCalls: { used: usage.toolCalls, limit: request.budget.maxToolCalls },
+                    elapsedMs: { used: Math.max(0, Date.now() - startedAt), limit: request.timeoutMs },
+                },
+            });
+            return Object.freeze({
+                result,
+                parentCancelled: status === 'cancelled' && Boolean(request.abortSignal?.aborted),
+                ...(persistedReceipt ? { receipt: persistedReceipt } : {}),
+            });
+        }
+        finally {
+            deadline.dispose();
+            usage.unsubscribe?.();
+        }
+    }
+    close(reason = 'production_subagent_runtime_closed') {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.tree.close(reason);
+    }
+    bindParentTurn(request) {
+        const key = `${request.parent.threadId}:${request.parent.turnId}`;
+        if (!this.parentTurnKey) {
+            this.parentTurnKey = key;
+            return;
+        }
+        if (this.parentTurnKey !== key) {
+            throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', 'A production subagent runtime and its tree limits belong to exactly one parent turn.');
+        }
+    }
+    createChildLoop(input, request, usage) {
+        const llm = this.options.createModelExecutor({
+            role: input.role,
+            objective: input.objective,
+            abortSignal: input.abortSignal,
+        });
+        if (!llm ||
+            typeof llm.chatStream !== 'function' ||
+            typeof llm.setProviderRequestPreflight !== 'function') {
+            throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_MODEL_PORT', 'Child model factory must return an isolated LLMService with provider preflight support.');
+        }
+        if (this.issuedModelExecutors.has(llm)) {
+            throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_MODEL_PORT', 'Child model factory reused mutable LLM state across child requests.');
+        }
+        this.issuedModelExecutors.add(llm);
+        const sharedPreflight = this.options.beforeProviderRequest;
+        llm.setProviderRequestPreflight(async (context) => {
+            const shared = sharedPreflight ? await sharedPreflight(context) : { available: true };
+            if (!shared.available)
+                return shared;
+            try {
+                input.budget.consumeModelRequests();
+                usage.providerAttempts += 1;
+                return shared;
+            }
+            catch (error) {
+                return { available: false, reason: errorMessage(error) };
+            }
+        });
+        if (typeof llm.subscribeUsage === 'function') {
+            usage.hasUsageObserver = true;
+            usage.unsubscribe = llm.subscribeUsage(event => observeUsage(usage, event));
+        }
+        const taskContext = (0, task_context_service_1.createTaskContextService)({
+            cwd: input.authority.projectRoot,
+            modelId: llm.getModel(),
+            config: { completionGate: 'off' },
+        });
+        const context = this.options.toolContext(request, input.authority);
+        if ((0, path_1.resolve)(context.cwd) !== (0, path_1.resolve)(input.authority.projectRoot)) {
+            throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', 'Child ToolContext cwd must match the narrowed authority root.');
+        }
+        const firstPartyPolicy = new first_party_tool_services_1.FirstPartyToolPolicyServiceV1(this.options.toolCatalog, context);
+        const policy = {
+            decide: (policyInput) => {
+                input.budget.consumeToolCalls();
+                usage.toolCalls += 1;
+                return firstPartyPolicy.decide(policyInput);
+            },
+        };
+        const gateway = new tool_gateway_1.ToolGateway({
+            policy,
+            approval: new first_party_tool_services_1.FirstPartyToolApprovalServiceV1(this.options.approvalHandler),
+            sandbox: new first_party_tool_services_1.FirstPartySandboxServiceV1(),
+            execution: new step_snapshot_1.ExecutionService(),
+            journal: new thread_tool_journal_1.ThreadToolInvocationJournalV1(input.childStore),
+        });
+        const capabilityJournal = new capability_receipt_journal_1.CapabilityReceiptJournalV1(input.childStore);
+        const registries = new Map();
+        const preparationKey = (step) => `${step.turnId}:${step.requestIndex}`;
+        const stepFactory = new capability_step_factory_1.CapabilityAgentLoopStepFactoryV1({
+            resolveConfiguration: async (step) => {
+                const configured = await this.options.resolveCapabilityConfiguration(step, {
+                    role: input.role,
+                    objective: input.objective,
+                    modelId: llm.getModel(),
+                    authority: input.authority,
+                    taskContext,
+                    toolCatalog: this.options.toolCatalog,
+                });
+                assertCapabilityConfiguration(configured, llm, input.authority);
+                const bindings = budgetedBindings(this.options.toolCatalog, input, request);
+                registries.set(preparationKey(step), bindings);
+                return {
+                    ...configured,
+                    compiler: {
+                        ...configured.compiler,
+                        task: {
+                            ...configured.compiler.task,
+                            objective: input.objective,
+                            activeInstruction: request.packet.expectedOutput,
+                        },
+                        authority: input.authority,
+                        tools: this.options.toolCatalog.candidates,
+                        runtimeServicesDigest: this.runtimeServicesDigest,
+                        executionPolicyDigest: configured.executionPolicy.digest,
+                    },
+                };
+            },
+            resolveToolRegistry: step => {
+                const key = preparationKey(step);
+                const registry = registries.get(key);
+                registries.delete(key);
+                if (!registry)
+                    throw new Error(`No frozen child tool registry exists for ${key}.`);
+                return registry;
+            },
+            onCaptured: bundle => {
+                capabilityJournal.commit(bundle);
+            },
+        });
+        const baseMessages = childBaseMessages(request, input.authority.projectRoot);
+        const turnCommits = new turn_commit_1.ThreadTurnCommitJournalV1(input.childStore);
+        const agentLoop = new agent_loop_1.AgentLoopV1({
+            llm,
+            taskContext,
+            steps: stepFactory,
+            gateway,
+            loadBaseMessages: () => baseMessages.map(message => ({ ...message })),
+            toolContext: () => context,
+            loopBudget: {
+                maxLlmRequestsPerUserTurn: input.budget.limits.maxModelRequests,
+                maxToolCallsPerUserTurn: input.budget.limits.maxToolCalls,
+            },
+            commitTurn: commit => commitAgentLoopTurn(turnCommits, commit),
+        });
+        return new CommitCompletingChildRunnerV1(agentLoop, input, taskContext, turnCommits, baseMessages);
+    }
+}
+exports.ProductionSubagentRuntimeV1 = ProductionSubagentRuntimeV1;
+/** Backward-compatible config derivation only; it does not construct a child loop. */
 function createChildLlmConfig(rootConfig) {
     return {
         apiKey: rootConfig.apiKey,
@@ -32,166 +301,221 @@ function createChildLlmConfig(rootConfig) {
         timeout: 60000,
     };
 }
-/**
- * Build the production {@link ExecuteChildQuery}. The returned function runs one
- * child to completion: it creates an isolated LLMService, drives `query()` with
- * the child messages + filtered tools, and returns the final assistant text and
- * observed usage. Never throws - provider errors surface as an empty result so
- * the runner normalizes them into a `failed` SubtaskResult.
- */
-function createProductionExecuteQuery(deps) {
-    const createLlm = deps.createLlm ?? ((config) => new llm_1.LLMService(config));
-    const runQuery = deps.runQuery ??
-        ((params) => (0, query_1.query)(params));
-    return async (messages, toolSet, abortSignal, reservedBudget) => {
-        const executionBudget = reservedBudget ?? {
-            maxModelRequests: deps.maxModelRequestsPerTask ?? deps.maxTurnsPerTask ?? 6,
-            maxToolCalls: deps.maxToolCallsPerTask ?? 24,
-        };
-        const llm = createLlm(createChildLlmConfig(deps.rootConfig));
-        // v0.2.26: inject the shared resilience coordinator so child requests
-        // also go through the retry/circuit-breaker/stream-recovery layer.
-        if (deps.resilience) {
-            llm.resilience = deps.resilience;
-        }
-        let providerAttempts = 0;
-        const providerPreflight = async (context) => {
-            if (providerAttempts >= executionBudget.maxModelRequests) {
-                return {
-                    available: false,
-                    reason: `Subagent provider request budget ${executionBudget.maxModelRequests} reached`,
-                };
-            }
-            const sharedDecision = deps.beforeProviderRequest
-                ? await deps.beforeProviderRequest(context)
-                : { available: true };
-            if (sharedDecision.available)
-                providerAttempts += 1;
-            return sharedDecision;
-        };
-        const restoreProviderPreflight = typeof llm.setProviderRequestPreflight === 'function'
-            ? llm.setProviderRequestPreflight(providerPreflight)
-            : undefined;
-        let finalContent = '';
-        const usage = { ...types_1.EMPTY_SUBTASK_USAGE };
-        const startedAt = Date.now();
-        let modelRequests = 0;
-        let observedModelRequests = 0;
-        let providerCostComplete = true;
-        let providerCostUsd = 0;
-        let completionUsageComplete = false;
-        let stopDecision;
-        const unsubscribeUsage = typeof llm.subscribeUsage === 'function'
-            ? llm.subscribeUsage(event => {
-                observedModelRequests++;
-                usage.promptTokens += event.usage.promptTokens;
-                usage.completionTokens += event.usage.completionTokens;
-                if (event.usage.costUsd === undefined)
-                    providerCostComplete = false;
-                else
-                    providerCostUsd += event.usage.costUsd;
-            })
-            : undefined;
-        const finalizeUsage = (usageComplete) => {
-            usage.modelRequests = Math.max(usage.modelRequests, modelRequests, observedModelRequests, providerAttempts);
-            usage.durationMs = Math.max(0, Date.now() - startedAt);
-            usage.usageComplete = usageComplete;
-            if (observedModelRequests > 0 && providerCostComplete)
-                usage.costUsd = providerCostUsd;
-        };
+function createProductionSubagentRuntimeV1(options) {
+    return new ProductionSubagentRuntimeV1(options);
+}
+class CommitCompletingChildRunnerV1 {
+    constructor(agentLoop, input, taskContext, commits, baseMessages) {
+        this.agentLoop = agentLoop;
+        this.input = input;
+        this.taskContext = taskContext;
+        this.commits = commits;
+        this.baseMessages = baseMessages;
+    }
+    async run(context) {
+        let outcome;
         try {
-            const params = {
-                messages: messages,
-                tools: toolSet.tools,
-                toolExecutor: toolSet.toolExecutor,
-                llm,
-                abortSignal,
-                loopBudget: {
-                    maxLlmRequestsPerUserTurn: executionBudget.maxModelRequests,
-                    maxToolCallsPerUserTurn: executionBudget.maxToolCalls,
-                },
-                // Children stream nothing to stdout; the root only sees the structured result.
-                streamCallbacks: { onChunk: () => undefined },
-            };
-            for await (const event of runQuery(params)) {
-                if (event.type === 'message' && event.role === 'assistant') {
-                    finalContent = event.content;
-                }
-                else if (event.type === 'complete') {
-                    finalContent = event.content;
-                    stopDecision = event.stats?.stopDecision;
-                    const loopUsage = loopStatsToUsage(event.stats, modelRequests, event.usage?.promptTokens, event.usage?.completionTokens);
-                    usage.modelRequests = loopUsage.modelRequests;
-                    usage.toolCalls = loopUsage.toolCalls;
-                    if (observedModelRequests === 0) {
-                        usage.promptTokens = loopUsage.promptTokens;
-                        usage.completionTokens = loopUsage.completionTokens;
-                    }
-                    const expectedSuccessfulRequests = Math.max(event.stats?.llmRequests ?? 0, loopUsage.modelRequests);
-                    const hasAggregateUsage = Boolean(event.usage &&
-                        Number.isFinite(event.usage.promptTokens) &&
-                        Number.isFinite(event.usage.completionTokens));
-                    const successfulUsageCovered = observedModelRequests >= expectedSuccessfulRequests || hasAggregateUsage;
-                    const unknownFailedAttempts = (event.stats?.providerRetryCount ?? 0) > 0 ||
-                        (event.stats?.providerFallbackCount ?? 0) > 0 ||
-                        (Boolean(unsubscribeUsage) && providerAttempts > observedModelRequests);
-                    completionUsageComplete = successfulUsageCovered && !unknownFailedAttempts;
-                }
-                else if (event.type === 'assistant_tool_calls') {
-                    modelRequests += 1;
-                    finalContent = event.content;
-                }
-                else if (event.type === 'tool_result') {
-                    usage.toolCalls += 1;
-                }
-            }
+            outcome = await this.agentLoop.run(context);
         }
-        catch (err) {
-            // A 429 with retry-after should pause siblings; surface the cooldown.
-            if (isRateLimitError(err)) {
-                const retryAfter = extractRetryAfterMs(err);
-                deps.providerGate.enterCooldown(retryAfter);
-            }
-            // Preserve already-observed usage as a lower bound. The runner
-            // normalizes this into failed/cancelled without losing provider cost.
-            finalizeUsage(false);
-            throw new types_1.SubtaskExecutionError(err instanceof Error ? err.message : String(err), usage);
+        catch (error) {
+            outcome = context.abortSignal.aborted
+                ? { status: 'interrupted', reason: errorMessage(error) }
+                : { status: 'failed', error: errorMessage(error) };
         }
-        finally {
-            unsubscribeUsage?.();
-            restoreProviderPreflight?.();
+        if (!this.input.childStore.loadProjection().turns[context.turnId]?.commit) {
+            const terminal = outcome.status === 'completed'
+                ? { status: 'completed', outcome: outcome.outcome }
+                : outcome.status === 'interrupted'
+                    ? { status: 'interrupted', reason: outcome.reason }
+                    : { status: 'failed', error: outcome.error };
+            const stopDecision = (0, stop_decision_1.createStopDecision)({
+                scope: 'subagent',
+                status: outcome.status === 'completed'
+                    ? 'completed'
+                    : outcome.status === 'interrupted'
+                        ? 'cancelled'
+                        : 'failed',
+                disposition: outcome.status === 'completed' ? 'finish_scope' : 'resume_allowed',
+                reason: {
+                    code: `child_${outcome.status}`,
+                    message: outcome.status === 'failed'
+                        ? outcome.error
+                        : outcome.status === 'interrupted'
+                            ? (outcome.reason ?? 'Child interrupted.')
+                            : (outcome.outcome ?? 'Child completed.'),
+                },
+                evidence: [],
+                nextActions: outcome.status === 'completed'
+                    ? [{ kind: 'inspect', label: 'Inspect child evidence.' }]
+                    : [{ kind: 'retry', label: 'Retry from the durable child boundary.' }],
+                resources: {},
+            });
+            this.commits.commit({
+                turnId: context.turnId,
+                history: [...this.baseMessages, { role: 'user', content: context.input }],
+                taskContextState: this.taskContext.exportState(),
+                taskContextRevision: this.taskContext.revision,
+                terminal,
+                stopDecision,
+            });
         }
-        finalizeUsage(completionUsageComplete);
-        return { content: finalContent, usage, stopDecision };
+        return outcome;
+    }
+}
+function commitAgentLoopTurn(commits, commit) {
+    commits.commit({
+        turnId: commit.turnId,
+        history: commit.history,
+        taskContextState: commit.taskContextState,
+        taskContextRevision: commit.taskContextRevision,
+        terminal: terminalFromAgentCommit(commit),
+        stopDecision: commit.queryComplete.stats?.stopDecision,
+    });
+}
+function terminalFromAgentCommit(commit) {
+    const finishReason = commit.queryComplete.stats?.finishReason;
+    if (finishReason === 'failed') {
+        return { status: 'failed', error: commit.queryComplete.content || 'Child AgentLoop failed.' };
+    }
+    if (finishReason === 'cancelled') {
+        return { status: 'interrupted', reason: 'Child AgentLoop cancelled.' };
+    }
+    return { status: 'completed', outcome: finishReason ?? 'completed' };
+}
+function budgetedBindings(catalog, input, request) {
+    return new Map([...catalog.bindings].map(([bindingId, binding]) => [
+        bindingId,
+        Object.freeze({
+            descriptor: binding.descriptor,
+            execute: async (args, context) => {
+                const containment = (0, child_executor_guard_1.evaluateToolCall)(binding.descriptor.name, args, {
+                    rootCwd: input.authority.projectRoot,
+                    scopePaths: request.canonicalScopePaths,
+                });
+                if (!containment.ok) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Subagent scope denied ${binding.descriptor.name}: ${containment.reason}`,
+                    };
+                }
+                return binding.execute(args, context);
+            },
+        }),
+    ]));
+}
+function childBaseMessages(request, cwd) {
+    const framed = (0, context_builder_1.buildChildMessages)({
+        cwd,
+        packet: request.packet,
+        canonicalScopePaths: request.canonicalScopePaths ? [...request.canonicalScopePaths] : undefined,
+        rootObjectiveSummary: request.rootObjectiveSummary,
+        modelLabel: request.modelLabel,
+    });
+    return Object.freeze([
+        {
+            role: 'system',
+            content: `${framed[0].content}\n\n# Delegation packet\n${framed[1].content}`,
+        },
+    ]);
+}
+function createUsageAccumulator() {
+    return {
+        providerAttempts: 0,
+        toolCalls: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        costUsd: 0,
+        costComplete: true,
+        hasUsageObserver: false,
+        successfulUsageEvents: 0,
     };
 }
-function loopStatsToUsage(stats, modelRequests, promptTokens, completionTokens) {
+function observeUsage(usage, event) {
+    usage.successfulUsageEvents += 1;
+    usage.promptTokens += event.usage.promptTokens;
+    usage.completionTokens += event.usage.completionTokens;
+    if (event.usage.costUsd === undefined)
+        usage.costComplete = false;
+    else
+        usage.costUsd += event.usage.costUsd;
+}
+function finalizeUsage(observed, charged, startedAt, completed) {
+    const usage = {
+        ...types_1.EMPTY_SUBTASK_USAGE,
+        modelRequests: Math.max(observed.providerAttempts, charged?.modelRequests ?? 0),
+        toolCalls: Math.max(observed.toolCalls, charged?.toolCalls ?? 0),
+        promptTokens: observed.promptTokens,
+        completionTokens: observed.completionTokens,
+        durationMs: Math.max(0, Date.now() - startedAt),
+        usageComplete: completed &&
+            observed.hasUsageObserver &&
+            observed.successfulUsageEvents >= observed.providerAttempts,
+    };
+    if (observed.hasUsageObserver && observed.costComplete)
+        usage.costUsd = observed.costUsd;
+    return usage;
+}
+function assertCapabilityConfiguration(configured, llm, authority) {
+    if (!configured || configured.model.modelId !== llm.getModel()) {
+        throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', 'Capability model snapshot must match the isolated child model.');
+    }
+    if (configured.environment.cwd !== authority.projectRoot) {
+        throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', 'Child capability environment must use the narrowed authority root.');
+    }
+}
+function validateOptions(options) {
+    if (!options.childStoreRootDir?.trim())
+        invalid('childStoreRootDir is required.');
+    if (!options.toolCatalog)
+        invalid('An explicit child tool catalog is required.');
+    if (options.toolCatalog.candidates.some(candidate => !candidate.descriptor.risk.readOnly)) {
+        invalid('Production investigation subagents accept only read-only tool bindings.');
+    }
+    if (typeof options.createModelExecutor !== 'function')
+        invalid('createModelExecutor is required.');
+    if (typeof options.resolveCapabilityConfiguration !== 'function') {
+        invalid('resolveCapabilityConfiguration is required.');
+    }
+    if (typeof options.toolContext !== 'function')
+        invalid('toolContext is required.');
+}
+function validateRequest(request) {
+    if (!request.taskId.trim() || !request.packet.objective.trim()) {
+        invalid('Subagent taskId and objective are required.');
+    }
+    if (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs <= 0) {
+        invalid('Subagent timeoutMs must be a positive safe integer.');
+    }
+}
+function invalid(message) {
+    throw new ProductionSubagentRuntimeError('ORION_SUBAGENT_PRODUCTION_INVALID', message);
+}
+function createDeadline(parent, timeoutMs) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const onAbort = () => controller.abort(parent?.reason);
+    if (parent?.aborted)
+        onAbort();
+    else
+        parent?.addEventListener('abort', onAbort, { once: true });
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new Error(`Subagent timed out after ${timeoutMs}ms.`));
+    }, timeoutMs);
+    timer.unref?.();
     return {
-        modelRequests: Math.max(modelRequests, stats?.llmRequests ?? modelRequests, 1),
-        toolCalls: stats?.toolCalls ?? 0,
-        promptTokens: promptTokens ?? 0,
-        completionTokens: completionTokens ?? 0,
-        durationMs: 0,
+        signal: controller.signal,
+        get timedOut() {
+            return timedOut;
+        },
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener('abort', onAbort);
+        },
     };
 }
-function isRateLimitError(err) {
-    if (!err || typeof err !== 'object')
-        return false;
-    const e = err;
-    const status = e.status ?? e.statusCode;
-    return status === 429 || /rate.?limit|429|too many requests/i.test(String(e.message ?? ''));
-}
-function extractRetryAfterMs(err) {
-    if (!err || typeof err !== 'object')
-        return 5000;
-    const e = err;
-    const headers = e.headers;
-    const retryAfter = headers?.['retry-after'];
-    if (retryAfter) {
-        const seconds = Number.parseFloat(retryAfter);
-        if (Number.isFinite(seconds))
-            return seconds * 1000;
-    }
-    return 5000; // conservative default cooldown
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 //# sourceMappingURL=production.js.map