@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/prepared-execution.js

@@ -1,6 +1,9 @@
+import { createRegisteredToolResultBudget, assertRegisteredToolResultMetadataFits, } from "./result-budget.js";
+import { randomUUID } from "node:crypto";
 import { requiresToolActionApproval } from "../../../../capabilities/tool-permission-mode.js";
 import { buildToolCompletedEventActions, buildToolCompletedEventMetadata, buildToolLifecycleEventCopy, } from "../../../../capabilities/tool-event-metadata.js";
 import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
+import { rejectNormalInvocation } from "../shared/rejection.js";
 import { requestNormalInvocationApproval } from "./approval.js";
 import { createPreparedInvocationRejectionEmitter } from "./rejection-event.js";
 import { createFileOutputPresentation } from "./file-output-presentation.js";
@@ -61,8 +64,9 @@ export function createPreparedNormalInvocation(params) {
             eventMeta: params.eventMeta,
             onEvent: params.executor.onEvent,
         }),
-        execute: (executionId, executorIdentity) => executePreparedNormalInvocation({
+        execute: (executionId, executorIdentity, selectedReferences) => executePreparedNormalInvocation({
             ...params,
+            selectedReferences,
             ...(approvalRequest ? { approvalRequest } : {}),
             ...(decision ? { decision, decisionRecorded } : {}),
             ...(executionId ? { executionId } : {}),
@@ -71,6 +75,12 @@ export function createPreparedNormalInvocation(params) {
     });
 }
 async function executePreparedNormalInvocation(params) {
+    const resultBudget = createRegisteredToolResultBudget({
+        call: params.call,
+        definition: params.target.registration.definition,
+        selectedReferences: params.selectedReferences,
+    });
+    assertRegisteredToolResultMetadataFits(resultBudget);
     const approval = await requestNormalInvocationApproval({
         ...(params.approvalRequest
             ? { preparedRequest: params.approvalRequest }
@@ -98,6 +108,27 @@ async function executePreparedNormalInvocation(params) {
     if (!approval.ok)
         return approval.rejection;
     params.executor.abortSignal.throwIfAborted();
+    const effectExecutionId = params.executionId ?? randomUUID();
+    const identity = (binding) => ({
+        toolName: binding.registration.toolName,
+        operationId: binding.operation.operationId,
+        contractVersion: binding.registration.contract.version,
+    });
+    const effectAdmission = await params.executor.effectPersistence?.beforeEffect({
+        executionId: effectExecutionId,
+        actionFingerprint: params.actionFingerprint,
+        source: identity(params.source),
+        target: identity(params.target),
+        effect: params.target.operation.effect,
+    });
+    const abortedBeforeDispatch = params.executor.abortSignal.aborted;
+    if (abortedBeforeDispatch) {
+        await params.executor.effectPersistence?.afterEffect({
+            executionId: effectExecutionId,
+            outcome: rejectNormalInvocation("request_aborted", "The operation was stopped before it began."),
+        });
+    }
+    params.executor.abortSignal.throwIfAborted();
     const startedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, "started");
     params.executor.onEvent?.("tool.started", {
         ...buildToolExecutorEventMetadata(params.executorIdentity),
@@ -108,32 +139,57 @@ async function executePreparedNormalInvocation(params) {
         ...(startedCopy ?? {}),
     });
     const fileOutputPresentation = createFileOutputPresentation(params.executor.sharedState?.runtimePaths);
-    const result = await executeWithToolResources({
-        registry: params.executor.toolRegistry,
-        call: params.call,
-        resources: params.executor.toolResources,
-        ...(params.executionId && params.executorIdentity
-            ? {
-                owner: {
-                    executionId: params.executionId,
-                    callId: params.executorIdentity.callId,
-                },
-            }
-            : {}),
-        options: {
-            abortSignal: params.executor.abortSignal,
-            reportFileOutput: fileOutputPresentation.report,
-            ...(params.executor.sharedState
-                ? { sharedState: params.executor.sharedState }
+    let result;
+    try {
+        result = await executeWithToolResources({
+            registry: params.executor.toolRegistry,
+            call: params.call,
+            resources: params.executor.toolResources,
+            ...(params.executionId && params.executorIdentity
+                ? {
+                    owner: {
+                        executionId: params.executionId,
+                        callId: params.executorIdentity.callId,
+                    },
+                }
                 : {}),
-        },
-    });
+            options: {
+                abortSignal: params.executor.abortSignal,
+                resultBudget,
+                ...(effectAdmission ? { trustedEffectAdmission: effectAdmission } : {}),
+                reportFileOutput: fileOutputPresentation.report,
+                ...(params.executor.sharedState
+                    ? { sharedState: params.executor.sharedState }
+                    : {}),
+            },
+        });
+    }
+    catch (error) {
+        await params.executor.effectPersistence?.afterEffect({
+            executionId: effectExecutionId,
+            outcome: {
+                status: "uncertain",
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
     const completionActions = Object.freeze(buildToolCompletedEventActions(params.call, result, params.target.registration.definition).map((action) => Object.freeze({ ...action })));
     const completedMeta = fileOutputPresentation.finish(result, buildToolCompletedEventMetadata(params.call, result, params.target.registration.definition), params.target.operation.effect);
     const completedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, result.ok ? "completed" : "failed");
     const completedEventMeta = params.executionMetadata
         ? { ...completedMeta, ...params.executionMetadata }
         : completedMeta;
+    const settled = Object.freeze({
+        status: "executed",
+        effect: params.target.operation.effect,
+        result,
+        completionActions,
+    });
+    await params.executor.effectPersistence?.afterEffect({
+        executionId: effectExecutionId,
+        outcome: settled,
+    });
     params.executor.onEvent?.("tool.completed", {
         ...buildToolExecutorEventMetadata(params.executorIdentity),
         ...(params.executionId ? { executionId: params.executionId } : {}),
@@ -143,10 +199,5 @@ async function executePreparedNormalInvocation(params) {
         ...(completedEventMeta ? { meta: completedEventMeta } : {}),
         ...(completedCopy ?? {}),
     });
-    return Object.freeze({
-        status: "executed",
-        effect: params.target.operation.effect,
-        result,
-        completionActions,
-    });
+    return settled;
 }

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/result-budget.d.ts

@@ -0,0 +1,11 @@
+import { type ToolResultBudget } from "../../../../capabilities/result-budget.js";
+import type { ToolCall, ToolDefinition } from "../../../../capabilities/tool-types.js";
+import type { CapabilityResultReference } from "../../../orchestration/capability-adapters/result.js";
+/** Invocation-owned delivery contract; it grants no model context or execution authority. */
+export declare function createRegisteredToolResultBudget(input: {
+    call: ToolCall;
+    definition: ToolDefinition;
+    selectedReferences?: readonly CapabilityResultReference[];
+}): ToolResultBudget;
+/** Metadata known before dispatch must leave space for even an empty result. */
+export declare function assertRegisteredToolResultMetadataFits(budget: ToolResultBudget): void;

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/result-budget.js

@@ -0,0 +1,30 @@
+import { assessResultEnvelopeBytes, } from "../../../../capabilities/result-budget.js";
+import { buildToolCompletedEventActions } from "../../../../capabilities/tool-event-metadata.js";
+import { measureToolContextTextBytes } from "../../../../capabilities/tool-context-text.js";
+import { projectToolExecutionResult } from "../../../../capabilities/tool-result-normalization.js";
+import { projectRegisteredToolResultEnvelope } from "../../registered-tool-worker-capabilities/result-envelope.js";
+/** Invocation-owned delivery contract; it grants no model context or execution authority. */
+export function createRegisteredToolResultBudget(input) {
+    const selectedReferences = Object.freeze([
+        ...(input.selectedReferences ?? []),
+    ]);
+    return Object.freeze({
+        acceptsContextText: true,
+        assess(output) {
+            const result = projectToolExecutionResult(input.call.tool, output);
+            const actions = buildToolCompletedEventActions(input.call, result, input.definition);
+            return assessResultEnvelopeBytes(projectRegisteredToolResultEnvelope(result, actions, selectedReferences), measureToolContextTextBytes(result));
+        },
+    });
+}
+/** Metadata known before dispatch must leave space for even an empty result. */
+export function assertRegisteredToolResultMetadataFits(budget) {
+    const assessment = budget.assess({
+        ok: true,
+        output: "",
+        producedNewInformation: false,
+    });
+    if (assessment.fits)
+        return;
+    throw new Error("registered_tool_result_metadata_exceeds_budget");
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/shared/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { CapabilityResultReference } from "../../../orchestration/capability-adapters/result.js";
 import type { BoundApprovalDecision } from "../../../orchestration/worker-capabilities/approval-contracts.js";
 import type { ToolEventExecutorIdentity } from "./event-metadata.js";
 import type { RequestToolResources } from "../../../capabilities/request-tool-resources.js";
@@ -50,7 +51,7 @@ export type RegisteredToolPreparedNormalInvocation = Readonly<{
         errorCode: string;
     }>): void;
     /** Canonical execution identity for client lifecycle events only. */
-    execute(executionId?: string, executorIdentity?: ToolEventExecutorIdentity): Promise<RegisteredToolNormalInvocationResult>;
+    execute(executionId?: string, executorIdentity?: ToolEventExecutorIdentity, selectedReferences?: readonly CapabilityResultReference[]): Promise<RegisteredToolNormalInvocationResult>;
 }>;
 export type RegisteredToolNormalInvocationPreparation = RegisteredToolPreparedNormalInvocation | RegisteredToolNormalInvocationRejection;
 export type RegisteredToolNormalInvocationPayloadLifecyclePhase = "started" | "completed" | "failed";
@@ -135,6 +136,31 @@ export type BoundOperation = Readonly<{
     payloadContextPlan?: RegisteredToolPayloadContextPlan;
     stagedPayloadPlan?: RegisteredToolStagedPayloadPlan;
 }>;
+/** Opt-in durable effect boundary used by non-interactive automation runs. */
+export type RegisteredToolEffectPersistence = Readonly<{
+    beforeEffect(input: Readonly<{
+        executionId: string;
+        actionFingerprint: string;
+        source: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+        }>;
+        target: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+        }>;
+        effect: ToolNormalInvocationEffect;
+    }>): Promise<object | void>;
+    afterEffect(input: Readonly<{
+        executionId: string;
+        outcome: RegisteredToolNormalInvocationResult | Readonly<{
+            status: "uncertain";
+            error: string;
+        }>;
+    }>): Promise<void>;
+}>;
 export type RegisteredToolNormalInvocationExecutorParams = Readonly<{
     toolResources?: RequestToolResources;
     registrations: readonly RegisteredToolNormalInvocation[];
@@ -146,6 +172,7 @@ export type RegisteredToolNormalInvocationExecutorParams = Readonly<{
     toolApprovalController?: ToolApprovalController;
     nextApprovalId(): string;
     onEvent?(name: string, payload: Record<string, unknown>): void;
+    effectPersistence?: RegisteredToolEffectPersistence;
 }>;
 export type RegisteredToolNormalInvocationPayloadLifecycleInput = Parameters<RegisteredToolNormalInvocationExecutor["emitPayloadLifecycle"]>[0];
 export type RegisteredToolNormalInvocationExecutionInput = Parameters<RegisteredToolNormalInvocationExecutor["execute"]>[0];

package/dist/src/runtime/adapters/registered-tool-payload-plan.d.ts

@@ -40,9 +40,9 @@ export type RegisteredToolPayloadTargetContext = Readonly<{
 }>;
 export declare function deriveRegisteredToolPayloadContextPlan(definition: ToolDefinition, operation: ToolNormalInvocationOperation): RegisteredToolPayloadContextPlan | undefined;
 /**
- * Bridges only explicitly staged tool metadata into the ordinary invocation
- * contract. Single-stage operations deliberately remain on their established
- * raw-payload path.
+ * Bridges explicitly declared payload stages into ordinary invocation.
+ * One declared stage retains its response format; operations with no declared
+ * stages keep their established raw-payload path.
  */
 export declare function deriveRegisteredToolStagedPayloadPlan(definition: ToolDefinition, operation: ToolNormalInvocationOperation): RegisteredToolStagedPayloadPlan | undefined;
 export type RegisteredToolPayloadStageLiteralResolution = Readonly<{

package/dist/src/runtime/adapters/registered-tool-payload-plan.js

@@ -14,13 +14,13 @@ export function deriveRegisteredToolPayloadContextPlan(definition, operation) {
     });
 }
 /**
- * Bridges only explicitly staged tool metadata into the ordinary invocation
- * contract. Single-stage operations deliberately remain on their established
- * raw-payload path.
+ * Bridges explicitly declared payload stages into ordinary invocation.
+ * One declared stage retains its response format; operations with no declared
+ * stages keep their established raw-payload path.
  */
 export function deriveRegisteredToolStagedPayloadPlan(definition, operation) {
     const spec = definition.payloadChannelSpec;
-    if (!spec?.stages || spec.stages.length < 2) {
+    if (!spec?.stages || spec.stages.length === 0) {
         return undefined;
     }
     if (!operation.payload ||

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/contracts.d.ts

@@ -3,6 +3,7 @@ import type { RegisteredToolNormalInvocation, ToolExecutionRequestContext, ToolN
 import type { WorkerCapabilityDescriptor, WorkerCapabilityPayloadAuthor } from "../../orchestration/worker-capabilities/index.js";
 import type { ToolApprovalController, ToolPermissionMode, ToolRegistry } from "../../ports.js";
 import type { RegisteredToolStagedPayloadPlan } from "../registered-tool-payload-plan.js";
+import type { RegisteredToolEffectPersistence } from "../registered-tool-normal-invocations/shared/contracts.js";
 export type RegisteredToolWorkerCapabilityProviderParams = Readonly<{
     toolResources?: RequestToolResources;
     /**
@@ -21,6 +22,7 @@ export type RegisteredToolWorkerCapabilityProviderParams = Readonly<{
     loadActionSkillContext?(toolName: string): Promise<string>;
     nextApprovalId(): string;
     onEvent?(name: string, payload: Record<string, unknown>): void;
+    effectPersistence?: RegisteredToolEffectPersistence;
 }>;
 export type SelectedOperation = Readonly<{
     registration: RegisteredToolNormalInvocation;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-authoring-result.js

@@ -1,4 +1,4 @@
-import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
+import { normalizePayloadBody } from "../../orchestration/worker-capabilities/payload-body-normalization.js";
 import { isPlainRecord } from "./values.js";
 export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, responseFormat) {
     if (!isPlainRecord(input) || Object.keys(input).length !== 2) {
@@ -8,13 +8,14 @@ export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, respo
         });
     }
     if (input.status === "authored" && typeof input.body === "string") {
-        const body = normalizeAdapterAuthoredBody(input.body, responseFormat);
-        if (body === undefined) {
+        const normalized = normalizePayloadBody(input.body, responseFormat);
+        if (!normalized.ok) {
             return Object.freeze({
                 status: "failed",
                 code: "payload_model_output_invalid",
             });
         }
+        const body = normalized.body;
         const payloadBytes = Buffer.byteLength(body, "utf8");
         if (payloadBytes < minBytes) {
             return Object.freeze({
@@ -34,21 +35,6 @@ export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, respo
         code: "payload_author_result_invalid",
     });
 }
-function normalizeAdapterAuthoredBody(body, responseFormat) {
-    if (!responseFormat)
-        return body;
-    try {
-        const parsed = JSON.parse(body);
-        if (responseFormat !== "json" &&
-            validateJsonSchemaValue(responseFormat, parsed)) {
-            return undefined;
-        }
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return undefined;
-    }
-}
 function isPayloadAuthorFailureCode(input) {
     return (input === "payload_context_invalid" ||
         input === "payload_context_budget_exceeded" ||

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/prepared-execution.js

@@ -34,9 +34,9 @@ export function createPreparedWorkerInvocation(params, input, normalPreparation,
                         exactResult: rejectedExecution.exactResult,
                     }, selectedTargetReferences);
                 }
-                const externalResult = await normalPreparation.execute(executionId, input.call);
-                const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null);
-                const observedResult = attachTargetReferences(observed.result, selectedTargetReferences);
+                const externalResult = await normalPreparation.execute(executionId, input.call, selectedTargetReferences);
+                const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null, selectedTargetReferences);
+                const observedResult = observed.result;
                 traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, executionId, observedResult, externalResult.status, {
                     ...(observed.sourceIssueCode
                         ? { sourceIssueCode: observed.sourceIssueCode }

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-envelope.d.ts

@@ -0,0 +1,13 @@
+import type { ToolActionSummary, ToolExecutionResult } from "../../../capabilities/tool-types.js";
+import type { CapabilityResultReference } from "../../orchestration/capability-adapters/result.js";
+/** This exact envelope is both measured for the producer and captured for settlement. */
+export declare function projectRegisteredToolResultEnvelope(result: ToolExecutionResult, completionActions: readonly ToolActionSummary[], selectedReferences?: readonly CapabilityResultReference[]): Readonly<{
+    references?: readonly Readonly<{
+        kind: "tool_target";
+        target: string;
+    }>[] | undefined;
+    kind: "registered_tool_execution_result_v1";
+    authority: "registered_plugin";
+    status: "executed";
+    result: ToolExecutionResult;
+}>;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-envelope.js

@@ -0,0 +1,15 @@
+import { projectTargetReferences } from "./result-references.js";
+/** This exact envelope is both measured for the producer and captured for settlement. */
+export function projectRegisteredToolResultEnvelope(result, completionActions, selectedReferences = []) {
+    const references = projectTargetReferences([
+        ...selectedReferences.map(({ target }) => target),
+        ...completionActions.map(({ target }) => target),
+    ]);
+    return Object.freeze({
+        kind: "registered_tool_execution_result_v1",
+        authority: "registered_plugin",
+        status: "executed",
+        result,
+        ...(references.length ? { references } : {}),
+    });
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-evidence.d.ts

@@ -2,16 +2,12 @@ import type { ToolActionSummary } from "../../../capabilities/tool-types.js";
 import { type RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
 import { type CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult } from "../../orchestration/worker-capabilities/index.js";
-import type { RegisteredToolNormalInvocationProjection, RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
+import type { RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
+export { projectSelectedTargetReferences, projectToolTargetReferences, } from "./result-references.js";
 export declare function summarizeCompletedMutation(completionActions: readonly ToolActionSummary[]): string;
 export declare function projectMutationGrounding(input: unknown, directRoot?: boolean): string | undefined;
-export declare function projectToolTargetReferences(completionActions: readonly ToolActionSummary[]): readonly Readonly<{
-    kind: "tool_target";
-    target: string;
-}>[];
-export declare function projectSelectedTargetReferences(projection: RegisteredToolNormalInvocationProjection, controls: Readonly<Record<string, unknown>>, directRootSelectionControlIds?: readonly string[]): readonly RoleCapabilityResultReference[];
 export declare function attachTargetReferences(result: WorkerCapabilityAdapterResult, selected: readonly RoleCapabilityResultReference[]): WorkerCapabilityAdapterResult;
-export declare function captureRegisteredToolResult(input: RegisteredToolNormalInvocationResult): CapabilityAdapterResult;
+export declare function captureRegisteredToolResult(input: RegisteredToolNormalInvocationResult, selectedReferences?: readonly RoleCapabilityResultReference[]): CapabilityAdapterResult;
 export declare function requireCapabilityAdapterResult(input: unknown): CapabilityAdapterResult;
 export declare function validateToolExecutionResult(input: unknown): void;
 export declare function boundedSummary(input: string, directRoot?: boolean): string;

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-evidence.js

@@ -1,5 +1,8 @@
-import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
 import { normalizeCapabilityAdapterResult, } from "../../orchestration/capability-adapters/index.js";
+import { projectTargetReferences } from "./result-references.js";
+export { projectSelectedTargetReferences, projectToolTargetReferences, } from "./result-references.js";
+import { projectRegisteredToolResultEnvelope } from "./result-envelope.js";
 import { executionProtocolError } from "./errors.js";
 import { isPlainRecord, nonEmpty } from "./values.js";
 const MUTATION_GROUNDING_MAX_LENGTH = 32_768;
@@ -26,17 +29,6 @@ export function projectMutationGrounding(input, directRoot = false) {
         ? normalized
         : `${normalized.slice(0, MUTATION_GROUNDING_MAX_LENGTH - 1)}…`;
 }
-export function projectToolTargetReferences(completionActions) {
-    return projectTargetReferences(completionActions.map(({ target }) => target));
-}
-export function projectSelectedTargetReferences(projection, controls, directRootSelectionControlIds) {
-    const targetParam = projection.stagedPayloadPlan?.targetParam ??
-        projection.payloadContextPlan?.targetParam;
-    const targetParams = targetParam
-        ? [targetParam]
-        : (directRootSelectionControlIds ?? []);
-    return projectTargetReferences(targetParams.map((param) => controls[param]));
-}
 export function attachTargetReferences(result, selected) {
     if (selected.length === 0)
         return result;
@@ -60,7 +52,7 @@ export function attachTargetReferences(result, selected) {
             : {}),
     });
 }
-export function captureRegisteredToolResult(input) {
+export function captureRegisteredToolResult(input, selectedReferences = []) {
     if (input.status === "rejected") {
         return requireCapabilityAdapterResult({
             kind: "runtime_capability_rejection_v1",
@@ -71,14 +63,7 @@ export function captureRegisteredToolResult(input) {
             message: input.message,
         });
     }
-    const references = projectToolTargetReferences(input.completionActions);
-    return requireCapabilityAdapterResult({
-        kind: "registered_tool_execution_result_v1",
-        authority: "registered_plugin",
-        status: "executed",
-        result: input.result,
-        ...(references.length > 0 ? { references } : {}),
-    });
+    return requireCapabilityAdapterResult(projectRegisteredToolResultEnvelope(input.result, input.completionActions, selectedReferences));
 }
 export function requireCapabilityAdapterResult(input) {
     const normalized = normalizeCapabilityAdapterResult(input);
@@ -87,23 +72,6 @@ export function requireCapabilityAdapterResult(input) {
     }
     return normalized.value;
 }
-function projectTargetReferences(values) {
-    const targets = new Set();
-    const references = [];
-    for (const value of values) {
-        const target = typeof value === "string" ? value.trim() : "";
-        if (!target ||
-            target.length > ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH ||
-            targets.has(target)) {
-            continue;
-        }
-        targets.add(target);
-        references.push(Object.freeze({ kind: "tool_target", target }));
-        if (references.length >= ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX)
-            break;
-    }
-    return Object.freeze(references);
-}
 export function validateToolExecutionResult(input) {
     if (!isPlainRecord(input) ||
         typeof input.ok !== "boolean" ||

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-observer.d.ts

@@ -1,8 +1,9 @@
+import type { RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
 import type { WorkerCapabilityAdapterResult } from "../../orchestration/worker-capabilities/index.js";
 import type { RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
 type ObservedExternalResult = Readonly<{
     result: WorkerCapabilityAdapterResult;
     sourceIssueCode?: string;
 }>;
-export declare function observeExternalResult(input: RegisteredToolNormalInvocationResult, expectedEffect: "read_only" | "mutating" | "mixed", directRoot: boolean): ObservedExternalResult;
+export declare function observeExternalResult(input: RegisteredToolNormalInvocationResult, expectedEffect: "read_only" | "mutating" | "mixed", directRoot: boolean, selectedReferences?: readonly RoleCapabilityResultReference[]): ObservedExternalResult;
 export { attachTargetReferences, boundedSummary, projectSelectedTargetReferences, requireCapabilityAdapterResult, } from "./result-evidence.js";

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-observer.js

@@ -1,22 +1,30 @@
 import { executionProtocolError } from "./errors.js";
 import { createRegisteredToolWorkerFailureOutcomeFingerprint } from "./failure-outcome-fingerprint.js";
-import { boundedSummary, captureRegisteredToolResult, projectMutationGrounding, projectObservationOutput, projectToolTargetReferences, summarizeCompletedMutation, validateToolExecutionResult, } from "./result-evidence.js";
+import { attachTargetReferences, boundedSummary, captureRegisteredToolResult, projectMutationGrounding, projectObservationOutput, projectToolTargetReferences, summarizeCompletedMutation, validateToolExecutionResult, } from "./result-evidence.js";
 import { isPlainRecord, nonEmpty, safeIssueCode } from "./values.js";
-export function observeExternalResult(input, expectedEffect, directRoot) {
+export function observeExternalResult(input, expectedEffect, directRoot, selectedReferences = []) {
     const observed = observeExternalResultLegacy(input, expectedEffect, directRoot);
-    const exactResult = captureRegisteredToolResult(input);
+    const exactResult = captureRegisteredToolResult(input, selectedReferences);
+    // Selected controls never changed the legacy failure identity.
+    const completionReferences = input.status === "executed"
+        ? projectToolTargetReferences(input.completionActions)
+        : [];
+    const { references: _selectedReferences, ...exactWithoutReferences } = exactResult;
+    const failureFingerprintSource = completionReferences.length
+        ? { ...exactWithoutReferences, references: completionReferences }
+        : exactWithoutReferences;
     return Object.freeze({
         ...observed,
-        result: observed.result.outcome === "failed"
+        result: attachTargetReferences(observed.result.outcome === "failed"
             ? Object.freeze({
                 ...observed.result,
                 exactResult,
-                failureOutcomeFingerprint: createRegisteredToolWorkerFailureOutcomeFingerprint(exactResult),
+                failureOutcomeFingerprint: createRegisteredToolWorkerFailureOutcomeFingerprint(failureFingerprintSource),
             })
             : Object.freeze({
                 ...observed.result,
                 exactResult,
-            }),
+            }), selectedReferences),
     });
 }
 function observeExternalResultLegacy(input, expectedEffect, directRoot) {

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-references.d.ts

@@ -0,0 +1,9 @@
+import type { ToolActionSummary } from "../../../capabilities/tool-types.js";
+import { type RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
+import type { RegisteredToolNormalInvocationProjection } from "../registered-tool-normal-invocations.js";
+export declare function projectToolTargetReferences(completionActions: readonly ToolActionSummary[]): readonly Readonly<{
+    kind: "tool_target";
+    target: string;
+}>[];
+export declare function projectSelectedTargetReferences(projection: RegisteredToolNormalInvocationProjection, controls: Readonly<Record<string, unknown>>, directRootSelectionControlIds?: readonly string[]): readonly RoleCapabilityResultReference[];
+export declare function projectTargetReferences(values: readonly unknown[]): readonly RoleCapabilityResultReference[];

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-references.js

@@ -0,0 +1,29 @@
+import { ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+export function projectToolTargetReferences(completionActions) {
+    return projectTargetReferences(completionActions.map(({ target }) => target));
+}
+export function projectSelectedTargetReferences(projection, controls, directRootSelectionControlIds) {
+    const targetParam = projection.stagedPayloadPlan?.targetParam ??
+        projection.payloadContextPlan?.targetParam;
+    const targetParams = targetParam
+        ? [targetParam]
+        : (directRootSelectionControlIds ?? []);
+    return projectTargetReferences(targetParams.map((param) => controls[param]));
+}
+export function projectTargetReferences(values) {
+    const targets = new Set();
+    const references = [];
+    for (const value of values) {
+        const target = typeof value === "string" ? value.trim() : "";
+        if (!target ||
+            target.length > ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH ||
+            targets.has(target)) {
+            continue;
+        }
+        targets.add(target);
+        references.push(Object.freeze({ kind: "tool_target", target }));
+        if (references.length >= ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX)
+            break;
+    }
+    return Object.freeze(references);
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities.js

@@ -110,6 +110,7 @@ export function createRegisteredToolWorkerCapabilityProvider(params) {
                         : {}),
                     nextApprovalId: params.nextApprovalId,
                     ...(params.onEvent ? { onEvent: params.onEvent } : {}),
+                    ...(params.effectPersistence ? { effectPersistence: params.effectPersistence } : {}),
                 });
                 adapters = projectWorkerAdapters({
                     operationIds: resolvedCatalog.operationIds,

package/dist/src/runtime/adapters/scheduler-executor-dispatch.d.ts

@@ -0,0 +1,11 @@
+import type { SchedulerAutomationExecutor, SchedulerExecutor } from "../scheduler/contracts.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
+/** Keep request and automation admission distinct under the same owner. */
+export declare function createSchedulerExecutorDispatch(options: {
+    request: SchedulerExecutor;
+    automation?: Omit<SchedulerAutomationExecutor, "tryReserve">;
+    admission: SessionRequestAdmission;
+}): {
+    executor: SchedulerExecutor;
+    automationExecutor?: SchedulerAutomationExecutor;
+};

package/dist/src/runtime/adapters/scheduler-executor-dispatch.js

@@ -0,0 +1,10 @@
+/** Keep request and automation admission distinct under the same owner. */
+export function createSchedulerExecutorDispatch(options) {
+    const automationExecutor = options.automation
+        ? {
+            ...options.automation,
+            tryReserve: (automationId) => options.admission.tryReserveAutomation(automationId),
+        }
+        : undefined;
+    return { executor: options.request, automationExecutor };
+}

package/dist/src/runtime/adapters/scheduler-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { RuntimeConfig, SessionStore } from "../ports.js";
 import type { RuntimeRequestHandler, RuntimeRequestOptions } from "../composition.js";
-import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { SchedulerAutomationExecutor, SchedulerRun } from "../scheduler/contracts.js";
 import type { SessionRequestAdmission } from "../request/session-admission.js";
 import { type ScheduledRequestEvent } from "./scheduled-request-outcome.js";
 export declare function createRuntimeScheduler(options: {
@@ -10,8 +10,10 @@ export declare function createRuntimeScheduler(options: {
     isDeleted(sessionId: string): boolean;
     handle: RuntimeRequestHandler["handle"];
     requestOptions?: (run: SchedulerRun) => RuntimeRequestOptions;
+    automationExecutor?: Omit<SchedulerAutomationExecutor, "tryReserve">;
 }): {
     scheduler: import("../scheduler/contracts.js").SchedulerService;
+    store: import("../scheduler/contracts.js").SchedulerStore;
     start: () => Promise<void>;
     ensureStarted(): Promise<void>;
     stop(): Promise<void>;