@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/runtime/request/execution-scope-surfaces.d.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
 import type { SuperFailureFinalization } from "./super-failure-explanation.js";
+import type { SupervisorSkillSelectionWindows } from "./supervisor-skill-selection-window.js";
 import type { RequestModelStepPort } from "../model/model-step-port.js";
 import { type RequestExecutionSeed, type RequestModelInvocationView } from "./contracts.js";
 import type { RequestSeedFacets } from "./execution-facets.js";
@@ -15,4 +16,5 @@ export declare function createScopeSurface(input: Readonly<{
     capabilities: RequestWorkerCapabilities;
     knowledgeSkillStore?: KnowledgeSkillStore;
     superFailureFinalization?: SuperFailureFinalization | undefined;
+    supervisorSkillSelectionWindows: SupervisorSkillSelectionWindows;
 }>): RequestExecutionScope;

package/dist/src/runtime/request/execution-scope-surfaces.js

@@ -14,6 +14,7 @@ export function createCapabilityCompositionView(facets, modelSteps) {
         requestId: enumerableGetter(() => facets.identity.requestId),
         runnerConfig: enumerableGetter(() => facets.model.runnerConfig),
         agentMode: enumerableGetter(() => facets.input.agentMode),
+        ...(facets.model.reasoningPreference ? { reasoningPreference: enumerableGetter(() => facets.model.reasoningPreference) } : {}),
         ...(facets.model.modelPreference !== undefined
             ? {
                 modelPreference: enumerableGetter(() => facets.model.modelPreference),
@@ -113,6 +114,7 @@ export function createScopeSurface(input) {
         policy: hiddenValue(policy),
         modelInvocation: hiddenValue(modelInvocation),
         capabilities: hiddenValue(capabilities),
+        supervisorSkillSelectionWindows: hiddenValue(input.supervisorSkillSelectionWindows),
         ...(input.knowledgeSkillStore ? { knowledgeSkillStore: hiddenValue(input.knowledgeSkillStore) } : {}),
         ...(input.superFailureFinalization
             ? {
@@ -167,6 +169,7 @@ function requestSeedDescriptors(facets, executionPolicySelection, includeSession
                 automationOutputContract: enumerableGetter(() => facets.input.automationOutputContract),
             }
             : {}),
+        ...(facets.model.reasoningPreference ? { reasoningPreference: enumerableGetter(() => facets.model.reasoningPreference) } : {}),
         ...(facets.model.modelPreference !== undefined
             ? {
                 modelPreference: enumerableGetter(() => facets.model.modelPreference),

package/dist/src/runtime/request/execution-scope.d.ts

@@ -6,6 +6,7 @@ import type { ToolAvailabilitySource } from "../capabilities/tool-availability.j
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
 import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
+import { type SupervisorSkillSelectionWindows } from "./supervisor-skill-selection-window.js";
 /** Request fields required while the request-bound capability catalog is built. */
 export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "sessionMemory" | "attachments" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
 /**
@@ -38,6 +39,7 @@ export type RequestExecutionScope = RequestExecutionSeed & BoundRequestModelInvo
     superFailureFinalization?: SuperFailureFinalization;
     workerCapabilities: RequestWorkerCapabilities;
     knowledgeSkillStore?: KnowledgeSkillStore;
+    supervisorSkillSelectionWindows: SupervisorSkillSelectionWindows;
 }>;
 export type CompiledRequestExecutionPolicy = RequestExecutionScope["executionPolicy"];
 export type RequestWorkerCapabilityProviderSource = Pick<RequestExecutionScope, "workerCapabilities">;

package/dist/src/runtime/request/execution-scope.js

@@ -6,6 +6,7 @@ import { createSuperFailureFinalization, } from "./super-failure-explanation.js"
 import { RequestModelStepInvoker } from "../model/invoke-step.js";
 import { createModelInvocationView, createRequestSeedFacets, } from "./execution-facets.js";
 import { createCapabilityCompositionView, createCapabilityExecutionView, createScopeSurface, REQUEST_EXECUTION_SCOPE, } from "./execution-scope-surfaces.js";
+import { createSupervisorSkillSelectionWindows } from "./supervisor-skill-selection-window.js";
 export function createRequestExecutionScope(input) {
     const facets = createRequestSeedFacets(input.seed);
     const policy = createRequestExecutionPolicyFacet(input.seed.executionPolicySelection, input.executionPolicy);
@@ -25,6 +26,7 @@ export function createRequestExecutionScope(input) {
         modelInvocation,
         modelSteps,
         capabilities,
+        supervisorSkillSelectionWindows: createSupervisorSkillSelectionWindows(),
         ...(input.knowledgeSkillStore && !isSkillStoreDeniedForModel(input.seed)
             ? { knowledgeSkillStore: input.knowledgeSkillStore }
             : {}),

package/dist/src/runtime/request/input.d.ts

@@ -7,5 +7,6 @@ export declare function parseRequestInput(msg: RunRequestMessage): {
     rawAttachments: unknown;
     rawAgentMode: unknown;
     rawModelPreference: unknown;
+    rawReasoningPreference?: unknown;
     toolPermissionMode: ToolPermissionMode;
 };

package/dist/src/runtime/request/input.js

@@ -11,6 +11,7 @@ export function parseRequestInput(msg) {
         rawAttachments: msg.attachments,
         rawAgentMode: msg.agentMode,
         rawModelPreference: msg.modelPreference,
+        rawReasoningPreference: msg.reasoningPreference,
         toolPermissionMode: resolveToolPermissionMode(msg.toolPermissionMode),
     };
 }

package/dist/src/runtime/request/prepared-execution.d.ts

@@ -47,6 +47,7 @@ export declare function prepareRequestExecution(params: RequestPreparationInput)
         attachments?: import("../../model-gateway/types.js").ModelGatewayAttachment[];
         agentMode: AgentMode;
         modelPreference?: import("../../model-gateway/types.js").ModelPreference;
+        reasoningPreference?: import("../../shared/model-reasoning.js").ModelReasoningPreference;
         modelPolicy?: import("../../model-gateway/types.js").ModelGatewayPolicyConfig;
         modelGatewayClient: Pick<import("../ports.js").ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
         contextCompactionStore?: import("../context/semantic-compaction/store.js").RequestContextCompactionStore;

package/dist/src/runtime/request/prepared-execution.js

@@ -1,3 +1,4 @@
+import { captureRequestReasoningPreference } from "./reasoning-preference.js";
 import { bindRequestWorkingDirectory } from "../capabilities/request-working-directory.js";
 import { createRuntimeToolPathResolver } from "../capabilities/runtime-target-path.js";
 import { isSparkSession } from "../../sessions/spark-session.js";
@@ -35,6 +36,7 @@ export async function prepareRequestExecution(params) {
             ? { modelExecutionPolicies: loaded.modelExecutionPolicies }
             : {}),
     });
+    const reasoningPreference = captureRequestReasoningPreference(input.rawReasoningPreference, selection);
     const executionPolicy = resolveRequestExecutionPolicy(resume?.snapshot.seed.executionPolicySelection?.policy ??
         selection.execution.policy);
     params.onFailurePolicyReady?.(executionPolicy);
@@ -127,6 +129,7 @@ export async function prepareRequestExecution(params) {
         executionPolicySelection: selection.execution,
         ...(modelAttachments?.length ? { attachments: modelAttachments } : {}),
         agentMode: selection.agentMode,
+        ...(reasoningPreference ? { reasoningPreference } : {}),
         ...(selection.modelPreference
             ? { modelPreference: selection.modelPreference }
             : {}),

package/dist/src/runtime/request/reasoning-preference.d.ts

@@ -0,0 +1,10 @@
+import { type ModelReasoningPreference } from "../../shared/model-reasoning.js";
+import type { ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
+/** Validate before session admission or tool effects; never infer a new model. */
+export declare function captureRequestReasoningPreference(value: unknown, selection: {
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    execution: {
+        primaryProfileId?: string;
+    };
+}): ModelReasoningPreference | undefined;

package/dist/src/runtime/request/reasoning-preference.js

@@ -0,0 +1,29 @@
+import { resolveProfileCandidate } from "../../shared/invocation-profile-selection.js";
+import { ModelReasoningConfigurationError, parseModelReasoningPreference, supportsModelReasoningBudget, } from "../../shared/model-reasoning.js";
+/** Validate before session admission or tool effects; never infer a new model. */
+export function captureRequestReasoningPreference(value, selection) {
+    const preference = parseModelReasoningPreference(value);
+    if (!preference)
+        return undefined;
+    const requestedId = selection.modelPreference?.profileId;
+    const selectedId = requestedId
+        ? resolveProfileCandidate({
+            profileId: requestedId,
+            policy: selection.modelPolicy,
+            source: "clientPreference",
+            resolveProfile: (id, policy) => policy?.profiles?.[id],
+        })?.profileId ?? requestedId
+        : selection.execution.primaryProfileId;
+    if (selectedId !== preference.profileId) {
+        throw new ModelReasoningConfigurationError("reasoning_preference_profile_mismatch", "reasoning preference must bind the requested model profile");
+    }
+    const profile = selection.modelPolicy?.profiles?.[preference.profileId];
+    const provider = profile?.provider ? selection.modelPolicy?.providers?.[profile.provider] : undefined;
+    if (!supportsModelReasoningBudget({
+        provider: provider?.type ?? "",
+        supportsThinking: profile?.supportsThinking,
+    })) {
+        throw new ModelReasoningConfigurationError("reasoning_budget_unsupported", `profile ${preference.profileId} does not declare numeric reasoning controls`);
+    }
+    return preference;
+}

package/dist/src/runtime/request/root-reference-action.js

@@ -15,13 +15,13 @@ export async function performRootReferenceAction(request, ledger, activation, re
     };
     if (params.decision.action === "recall_memory") {
         await performRootMemoryRecall({ ...params, query: params.decision.query });
-        return params.resume;
+        return projectResumeAfterRootReferenceAction(params.ledger.current(), params.resume);
     }
     await performRootSkillRead({ ...params, decision: params.decision });
-    return projectResumeAfterSkillRead(params.ledger.current(), params.resume);
+    return projectResumeAfterRootReferenceAction(params.ledger.current(), params.resume);
 }
 /** A reference read advances the root activation without changing its completed children. */
-function projectResumeAfterSkillRead(head, resume) {
+function projectResumeAfterRootReferenceAction(head, resume) {
     if (!resume)
         return undefined;
     const call = head.state.calls.find(({ callId }) => callId === resume.callerCallId);

package/dist/src/runtime/request/root-skill-read-admission.d.ts

@@ -0,0 +1,4 @@
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { SkillReadDecision } from "../steps/skill-read-decision.js";
+/** Enforce request-local read identity before any document lookup or ledger commit. */
+export declare function assertRootSkillReadAdmission(head: RoleCallLedgerHead, decision: SkillReadDecision): void;

package/dist/src/runtime/request/root-skill-read-admission.js

@@ -0,0 +1,14 @@
+import { collectSuccessfulSkillReadIdentities } from "../steps/supervisor-decision/skill-read-state.js";
+/** Enforce request-local read identity before any document lookup or ledger commit. */
+export function assertRootSkillReadAdmission(head, decision) {
+    if (decision.action !== "read_skills")
+        return;
+    const hasRepeatedRootSkillReadIds = new Set(decision.skillIds).size !== decision.skillIds.length;
+    if (hasRepeatedRootSkillReadIds)
+        throw new Error("skill_read_duplicate_ids");
+    const completedIds = new Set(collectSuccessfulSkillReadIdentities(head.state.skillReads ?? [])
+        .map(({ skillId }) => skillId));
+    const repeatsCompletedRootSkillRead = decision.skillIds.some((skillId) => completedIds.has(skillId));
+    if (repeatsCompletedRootSkillRead)
+        throw new Error("skill_read_already_completed");
+}

package/dist/src/runtime/request/root-skill-read.js

@@ -1,9 +1,9 @@
 import { findRoleActivationReservationIssue, resolveRoleActivationBudget, } from "../orchestration/role-calls/activation-budget.js";
 import { hasSuperContextContract } from "../context/super-context-policy.js";
 import { KnowledgeSkillError } from "../knowledge-skills/personal-contracts.js";
-import { resolveKnowledgeSkillReadTargets } from "../capabilities/knowledge-skills/read-targets.js";
 import { emitRuntimeStatus } from "../events/runtime-status.js";
 import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { assertRootSkillReadAdmission } from "./root-skill-read-admission.js";
 /** Read synchronously, then commit the exact snapshot and the next root activation together. */
 export async function performRootSkillRead(params) {
     const { request, head, call } = params;
@@ -29,6 +29,7 @@ export async function performRootSkillRead(params) {
     const exhausted = findRoleActivationReservationIssue(head.state, head.policy, reservation);
     if (exhausted)
         throw new Error(`role_call_ledger_rejected:${exhausted.code}`);
+    assertRootSkillReadAdmission(head, params.decision);
     const payload = readStore(request.knowledgeSkillStore, params.decision);
     request.abortSignal.throwIfAborted();
     if (!steering.isCurrent(params.steeringVersion))
@@ -56,15 +57,19 @@ function readStore(store, decision) {
                     skills: store.list().map((skill) => ({ ...skill })),
                 },
             };
-        const resolved = resolveKnowledgeSkillReadTargets(store, decision.skillIds);
-        if (!resolved.ok)
-            return failedRead(decision, resolved.errorCode);
+        const skills = [];
+        for (const skillId of decision.skillIds) {
+            const skill = store.read(skillId);
+            if (!isExactRootSkillDocument(skill, skillId))
+                return failedRead(decision, "knowledge_skill_not_found");
+            skills.push({ ...skill });
+        }
         return {
             operation: "read_skills",
             selectors: [...decision.skillIds],
             result: {
                 outcome: "completed",
-                skills: resolved.skills.map((skill) => ({ ...skill })),
+                skills,
             },
         };
     }
@@ -74,6 +79,9 @@ function readStore(store, decision) {
         throw error;
     }
 }
+function isExactRootSkillDocument(skill, skillId) {
+    return skill?.skillId === skillId;
+}
 function failedRead(decision, errorCode) {
     const result = { outcome: "failed", errorCode, skills: [] };
     if (decision.action === "list_skills")

package/dist/src/runtime/request/supervisor-skill-selection-window.d.ts

@@ -0,0 +1,16 @@
+export type SupervisorSkillSelectionWindow = Readonly<{
+    isOpen(): boolean;
+    complete(): void;
+}>;
+export type SupervisorSkillSelectionWindows = Readonly<{
+    bind(entry: Readonly<{
+        rootCallId: string;
+        returnedResultRef?: string;
+    }>): SupervisorSkillSelectionWindow;
+}>;
+/**
+ * Request-local preparation progress, never session or checkpoint state.
+ * A canonical direct-child result identifies a new entry into Supervisor.
+ * Repeated activations, steering and reference reads retain the same entry.
+ */
+export declare function createSupervisorSkillSelectionWindows(): SupervisorSkillSelectionWindows;

package/dist/src/runtime/request/supervisor-skill-selection-window.js

@@ -0,0 +1,17 @@
+/**
+ * Request-local preparation progress, never session or checkpoint state.
+ * A canonical direct-child result identifies a new entry into Supervisor.
+ * Repeated activations, steering and reference reads retain the same entry.
+ */
+export function createSupervisorSkillSelectionWindows() {
+    const completedEntries = new Set();
+    return Object.freeze({
+        bind(entry) {
+            const key = JSON.stringify([entry.rootCallId, entry.returnedResultRef ?? null]);
+            return Object.freeze({
+                isOpen: () => !completedEntries.has(key),
+                complete: () => { completedEntries.add(key); },
+            });
+        },
+    });
+}

package/dist/src/runtime/request/worker-capability-composition.js

@@ -1,3 +1,4 @@
+import { allowsAutomaticPayloadArtifactLoading } from "./execution-payload-artifact-policy.js";
 import { projectAvailableSkills, } from "../knowledge-skills/available-skills.js";
 import { randomUUID } from "node:crypto";
 import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "../adapters/configured-skill-provider.js";
@@ -42,6 +43,7 @@ export function createRequestWorkerCapabilityProvider(params) {
     }
     const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
+        allowRelatedArtifactLoading: allowsAutomaticPayloadArtifactLoading(params.executionPolicyAuthority),
         requestId: params.request.requestId,
         ...(params.request.toolResources
             ? { toolResources: params.request.toolResources }

package/dist/src/runtime/scheduler/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { ModelReasoningPreference } from "../../shared/model-reasoning.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { AutomationJournalState } from "../automations/storage-records.js";
 import type { SchedulerToolPermissionMode } from "./tool-permission-mode.js";
@@ -67,6 +68,7 @@ export interface SchedulerJob {
     prompt: string;
     modelProfileId: string;
     agentMode: AgentMode;
+    reasoningPreference?: ModelReasoningPreference;
     toolPermissionMode: SchedulerToolPermissionMode;
     timeZone: string;
     schedule: SchedulerTimedSchedule;
@@ -109,10 +111,13 @@ export interface CreateSchedulerJobInput {
     prompt: string;
     modelProfileId: string;
     agentMode: AgentMode;
+    reasoningPreference?: ModelReasoningPreference;
     timeZone: string;
     schedule: SchedulerScheduleInput;
 }
-export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId">>;
+export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId" | "reasoningPreference">> & {
+    reasoningPreference?: ModelReasoningPreference | null;
+};
 export type SchedulerRunStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled" | "interrupted" | "missed";
 export interface SchedulerRun {
     /** Legacy records omit this discriminator and are normalized when loaded. */
@@ -130,6 +135,7 @@ export interface SchedulerRun {
     prompt: string;
     modelProfileId: string;
     agentMode: AgentMode;
+    reasoningPreference?: ModelReasoningPreference;
     timeZone: string;
     jobRevision: number;
     scheduledAt: string;

package/dist/src/runtime/scheduler/job-management.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { randomUUID } from "node:crypto";
 import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
@@ -26,6 +27,7 @@ export function createSchedulerJob(context, input) {
             prompt: input.prompt,
             modelProfileId: input.modelProfileId,
             agentMode: input.agentMode,
+            ...(input.reasoningPreference ? { reasoningPreference: parseBoundModelReasoningPreference(input.reasoningPreference, input.modelProfileId) } : {}),
             toolPermissionMode: requireSchedulerToolPermissionMode(input.toolPermissionMode),
             timeZone: input.timeZone,
             schedule,
@@ -53,7 +55,7 @@ export function updateSchedulerJob(context, jobId, patch) {
             if (job.state === "cancelled")
                 throw new Error("scheduler_job_cancelled");
             const editable = pickEditableFields(patch);
-            const input = { ...job, ...editable };
+            const input = { ...job, ...editable, reasoningPreference: editable.reasoningPreference === null ? undefined : (editable.reasoningPreference ?? job.reasoningPreference) };
             validateSchedulerJobInput(input);
             const now = context.now();
             const schedule = normalizeSchedulerScheduleUpdate(job.schedule, editable.schedule, now);
@@ -71,6 +73,7 @@ export function updateSchedulerJob(context, jobId, patch) {
             const pending = findPendingRun(state, jobId);
             cancelPendingRuns(state, jobId, new Date(now).toISOString());
             Object.assign(job, editable, {
+                reasoningPreference: parseBoundModelReasoningPreference(input.reasoningPreference, input.modelProfileId),
                 schedule,
                 nextRunAt,
                 updatedAt: new Date(now).toISOString(),
@@ -103,6 +106,8 @@ function hasSchedulerTimingChanges(job, candidate) {
 function hasSchedulerJobChanges(job, candidate) {
     if (hasSchedulerTimingChanges(job, candidate))
         return true;
+    if (JSON.stringify(job.reasoningPreference) !== JSON.stringify(candidate.reasoningPreference))
+        return true;
     return [
         "title",
         "prompt",
@@ -119,6 +124,7 @@ function pickEditableFields(patch) {
         "prompt",
         "modelProfileId",
         "agentMode",
+        "reasoningPreference",
         "toolPermissionMode",
         "timeZone",
         "schedule",

package/dist/src/runtime/scheduler/run-records.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { randomUUID } from "node:crypto";
 import { isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function makeSchedulerRun(job, scheduledAt, trigger) {
@@ -11,6 +12,7 @@ export function makeSchedulerRun(job, scheduledAt, trigger) {
         prompt: job.prompt,
         modelProfileId: job.modelProfileId,
         agentMode: job.agentMode,
+        ...(job.reasoningPreference ? { reasoningPreference: parseBoundModelReasoningPreference(job.reasoningPreference, job.modelProfileId) } : {}),
         toolPermissionMode: job.toolPermissionMode,
         timeZone: job.timeZone,
         jobRevision: job.revision,

package/dist/src/runtime/scheduler/schedule-validation.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { SchedulerValidationError } from "./validation-error.js";
 import { parseSchedulerInstant, schedulerInstantFromMilliseconds, } from "./instant-validation.js";
@@ -28,6 +29,7 @@ export function validateSchedulerJobInput(input) {
     if (!allowedModes.includes(input.agentMode)) {
         throw new SchedulerValidationError("scheduler_invalid_job", "agentMode is invalid");
     }
+    parseBoundModelReasoningPreference(input.reasoningPreference, input.modelProfileId);
     requireSchedulerToolPermissionMode(input.toolPermissionMode);
     validateTimeZone(input.timeZone);
 }

package/dist/src/runtime/scheduler/scheduler-engine.js

@@ -164,6 +164,7 @@ function startCapturedRun(context, job, run) {
             title: run.title,
             modelProfileId: run.modelProfileId,
             agentMode: run.agentMode,
+            reasoningPreference: run.reasoningPreference,
             toolPermissionMode: run.toolPermissionMode ?? "full_access",
             timeZone: run.timeZone,
             revision: run.jobRevision,

package/dist/src/runtime/scheduler/snapshot-validation.js

@@ -1,3 +1,4 @@
+import { parseBoundModelReasoningPreference } from "../../shared/model-reasoning.js";
 import { parseStoredAutomationJob, parseStoredAutomationRun, } from "./automation-snapshot-validation.js";
 import { sameSchedulerTarget } from "./scheduler-target.js";
 import { normalizeStoredSchedulerSchedule, validateSchedulerJobInput, validateTimeZone, } from "./schedule-validation.js";
@@ -74,6 +75,7 @@ export function parseStoredRun(value) {
         failSnapshot();
     if (Number(value.jobRevision) < 1)
         failSnapshot();
+    parseBoundModelReasoningPreference(value.reasoningPreference, String(value.modelProfileId));
     requireSchedulerToolPermissionMode(value.toolPermissionMode);
     validateTimeZone(String(value.timeZone));
     const states = [

package/dist/src/runtime/steps/auditor-decision/projection.js

@@ -21,6 +21,8 @@ export function projectAuditorAssignment(request, head, call) {
         prompt: request.prompt,
         objective: projectExecutionCompactionObjective(request.prompt, steering.updates),
         callId: caller.callId,
+        updates: steering.updates,
+        sourceRevision: head.revision,
         store: request.contextCompactionStore,
         results: head.state.capabilityExecutions
             .filter((execution) => execution.callId === caller.callId && execution.status === "settled")

package/dist/src/runtime/steps/execution-agent/capability-controls-partition.d.ts

@@ -0,0 +1,9 @@
+import { type CapabilityControlsPartitionResult, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+/** The evidence-owning EA selects the complete operation for ordinary observations. */
+export declare function ownsExecutionObservationControls(descriptor: CapabilityDescriptor): boolean;
+/**
+ * This is an EA model-facing projection, not a change to the shared descriptor.
+ * Optional controls remain optional: a generated null is an intentional omission,
+ * normalized by the decision parser before execution, never a later choice.
+ */
+export declare function partitionExecutionCapabilityControls(descriptor: CapabilityDescriptor): CapabilityControlsPartitionResult;

package/dist/src/runtime/steps/execution-agent/capability-controls-partition.js

@@ -0,0 +1,29 @@
+import { EMPTY_CAPABILITY_CONTROLS_SCHEMA, partitionCapabilityControlsSchema, } from "../../orchestration/capability-adapters/index.js";
+/** The evidence-owning EA selects the complete operation for ordinary observations. */
+export function ownsExecutionObservationControls(descriptor) {
+    if (descriptor.effect !== "observation")
+        return false;
+    return descriptor.requiresPayloadAuthoringObjective !== true;
+}
+/**
+ * This is an EA model-facing projection, not a change to the shared descriptor.
+ * Optional controls remain optional: a generated null is an intentional omission,
+ * normalized by the decision parser before execution, never a later choice.
+ */
+export function partitionExecutionCapabilityControls(descriptor) {
+    const partition = partitionCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
+    if (!partition.ok)
+        return partition;
+    if (!ownsExecutionObservationControls(descriptor))
+        return partition;
+    const fullSchema = partition.value.fullSchema;
+    return Object.freeze({
+        ok: true,
+        value: Object.freeze({
+            fullSchema,
+            selectionSchema: fullSchema,
+            remainingSchema: EMPTY_CAPABILITY_CONTROLS_SCHEMA,
+            selectionControlIds: Object.freeze(Object.keys(fullSchema.properties)),
+        }),
+    });
+}

package/dist/src/runtime/steps/execution-agent/capability-scope.d.ts

@@ -0,0 +1,17 @@
+import { type CapabilityCatalogGroup, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type RequestExecutionScope } from "../../request/execution-scope.js";
+/** One decision-local capability offer shared by guidance loading and input. */
+export type ExecutionCapabilityScope = Readonly<{
+    capabilities: readonly CapabilityDescriptor[];
+    capabilityCatalogGroups: readonly CapabilityCatalogGroup[];
+    activeCapabilityCatalogGroupIds: readonly string[] | null;
+    knownGroupIds: readonly string[];
+    remainingExecutions: number;
+    capabilityScopeAction: "open" | "extend" | null;
+}>;
+export declare function resolveExecutionCapabilityScope(request: RequestExecutionScope, options: Readonly<{
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}>): ExecutionCapabilityScope;
+export declare function assertExecutionAgentCanonicalSource(request: RequestExecutionScope, head: RoleCallLedgerHead, call: RoleCallFrame): void;

package/dist/src/runtime/steps/execution-agent/capability-scope.js

@@ -0,0 +1,54 @@
+import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
+import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+export function resolveExecutionCapabilityScope(request, options) {
+    assertExecutionAgentCanonicalSource(request, options.head, options.call);
+    const allCapabilities = resolveRequestWorkerCapabilities(request).provider.getDescriptors();
+    const capabilityCatalogGroups = projectCapabilityCatalogGroups(allCapabilities);
+    const activeCapabilityCatalogGroupIds = options.call.workerCapabilityScope
+        ? Object.freeze([...options.call.workerCapabilityScope.catalogGroupIds])
+        : null;
+    const remainingExecutions = options.head.policy.limits.maxCapabilityExecutions -
+        options.head.state.capabilityExecutions.length;
+    const capabilities = canOfferScopedCapabilities(activeCapabilityCatalogGroupIds, remainingExecutions)
+        ? projectCapabilityScope({
+            entries: allCapabilities,
+            scope: options.call.workerCapabilityScope,
+            descriptorOf: (entry) => entry,
+        }).entries
+        : Object.freeze([]);
+    const knownGroupIds = Object.freeze(capabilityCatalogGroups.map(({ groupId }) => groupId));
+    return Object.freeze({
+        capabilities,
+        capabilityCatalogGroups,
+        activeCapabilityCatalogGroupIds,
+        knownGroupIds,
+        remainingExecutions,
+        capabilityScopeAction: resolveCapabilityScopeAction(activeCapabilityCatalogGroupIds, knownGroupIds, remainingExecutions),
+    });
+}
+export function assertExecutionAgentCanonicalSource(request, head, call) {
+    if (head.state.requestId !== request.requestId ||
+        head.state.phase !== "running" ||
+        head.state.rootCallId !== call.callId ||
+        head.state.activeCallId !== call.callId ||
+        call.parentCallId !== null ||
+        call.status !== "active") {
+        throw new Error("execution_agent_head_invalid");
+    }
+}
+function canOfferScopedCapabilities(activeGroupIds, remainingExecutions) {
+    if (activeGroupIds === null)
+        return false;
+    return remainingExecutions > 0;
+}
+function resolveCapabilityScopeAction(activeGroupIds, knownGroupIds, remainingExecutions) {
+    if (remainingExecutions <= 0)
+        return null;
+    if (knownGroupIds.length === 0)
+        return null;
+    if (activeGroupIds === null)
+        return "open";
+    if (knownGroupIds.some((groupId) => !activeGroupIds.includes(groupId)))
+        return "extend";
+    return null;
+}

package/dist/src/runtime/steps/execution-agent/compaction.js

@@ -1,9 +1,27 @@
+import { resolveExecutionEvidenceCheckpoint } from "../../context/execution-compaction-checkpoint-selection.js";
 import { executionCompactionScopeId, projectExecutionCompactionObjective, } from "../../context/execution-compaction-objective.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
 import { buildExecutionCapabilityResultSource } from "./capability-result-context.js";
 export function createExecutionAgentCompactionController(request, options) {
     const objective = projectExecutionCompactionObjective(request.prompt, options.steeringSnapshot.updates);
     const call = Object.freeze({ ...options.call, objective });
+    const scopeId = executionCompactionScopeId({
+        callId: call.callId,
+        prompt: request.prompt,
+        objective,
+        ...(options.scopeSuffix ? { scopeSuffix: options.scopeSuffix } : {}),
+    });
+    const checkpoint = resolveExecutionEvidenceCheckpoint({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        objective,
+        callId: call.callId,
+        store: request.contextCompactionStore,
+        updates: options.steeringSnapshot.updates,
+        allowedConsumers: options.allowedConsumers,
+        scopeSuffix: options.scopeSuffix,
+        sourceRevision: options.head.revision,
+    });
     return createModelStepCompactionController(request, {
         call,
         sourceRevision: options.head.revision,
@@ -16,11 +34,9 @@ export function createExecutionAgentCompactionController(request, options) {
             .map((execution) => buildExecutionCapabilityResultSource(options.head, execution)),
         allowedConsumers: options.allowedConsumers,
         consumer: options.consumer,
-        scopeId: executionCompactionScopeId({
-            callId: call.callId,
-            prompt: request.prompt,
-            objective,
-            ...(options.scopeSuffix ? { scopeSuffix: options.scopeSuffix } : {}),
-        }),
+        scopeId,
+        ...(checkpoint && checkpoint.scopeId !== scopeId
+            ? { inheritedCheckpoint: checkpoint }
+            : {}),
     });
 }

package/dist/src/runtime/steps/execution-agent/controls-compacted-evidence.js

@@ -14,6 +14,8 @@ export function buildExecutionControlsEvidenceMessage(view, params) {
         prompt: params.compaction.prompt,
         objective: projectExecutionCompactionObjective(params.compaction.prompt, params.steering.updates),
         callId: params.callId,
+        updates: params.steering.updates,
+        sourceRevision: view.sourceRevision,
         store: params.compaction.store,
         results: view.results.map((result) => ({
             ...result,

package/dist/src/runtime/steps/execution-agent/evidence-reuse-instructions.d.ts

@@ -0,0 +1,6 @@
+/** Decision-only policy; source evidence remains in its canonical context lane. */
+export declare const EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS: string;
+export declare function appendExecutionEvidenceReuseInstructions(params: Readonly<{
+    instructions: string;
+    hasCapabilities: boolean;
+}>): string;