@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/projects/repository.js

@@ -1,49 +1,56 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { copySessionProject } from "../../sessions/project-binding.js";
-/** One environment owner serializes updates; rename publishes a complete registry. */
+import { readProjectCatalog } from "./registry-format.js";
+/** One environment owner serializes updates; rename publishes a complete catalog. */
 export class FileProjectRepository {
     filename;
     tail = Promise.resolve();
     constructor(filename) {
         this.filename = filename;
     }
-    async list() {
+    async catalog() {
         try {
-            const input = JSON.parse(await readFile(this.filename, "utf8"));
-            if (!Array.isArray(input))
-                throw new Error("project_registry_invalid");
-            return input.map((entry) => {
-                const project = copySessionProject(entry);
-                if (typeof entry.createdAt !== "string")
-                    throw new Error("project_registry_created_at_invalid");
-                return { ...project, createdAt: entry.createdAt };
-            });
+            return readProjectCatalog(JSON.parse(await readFile(this.filename, "utf8")));
         }
         catch (error) {
             if (error.code === "ENOENT")
-                return [];
+                return { projects: [], deletedProjectIds: [] };
             throw error;
         }
     }
+    async list() {
+        return (await this.catalog()).projects;
+    }
     create(project) {
-        const result = this.tail.then(async () => {
-            const projects = await this.list();
-            const existing = projects.find((entry) => entry.directory === project.directory);
+        return this.mutate(async (catalog) => {
+            const existing = catalog.projects.find((entry) => entry.directory === project.directory);
             if (existing)
                 return existing;
-            await this.save([...projects, project]);
+            await this.save({ ...catalog, projects: [...catalog.projects, project] });
             return project;
         });
+    }
+    delete(projectId) {
+        return this.mutate(async (catalog) => {
+            if (catalog.deletedProjectIds.includes(projectId))
+                return;
+            await this.save({
+                projects: catalog.projects.filter((project) => project.id !== projectId),
+                deletedProjectIds: [...catalog.deletedProjectIds, projectId],
+            });
+        });
+    }
+    mutate(apply) {
+        const result = this.tail.then(async () => apply(await this.catalog()));
         this.tail = result.then(() => undefined, () => undefined);
         return result;
     }
-    async save(projects) {
+    async save(catalog) {
         await mkdir(dirname(this.filename), { recursive: true });
         const temporary = `${this.filename}.${process.pid}.${randomUUID()}.tmp`;
         try {
-            await writeFile(temporary, JSON.stringify(projects, null, 2), "utf8");
+            await writeFile(temporary, JSON.stringify({ version: 1, ...catalog }, null, 2), "utf8");
             await rename(temporary, this.filename);
         }
         catch (error) {

package/dist/src/runtime/projects/service.js

@@ -4,11 +4,22 @@ import { copySessionProject } from "../../sessions/project-binding.js";
 import { FileProjectRepository } from "./repository.js";
 import { browseProjectFolders, projectDisplayName, resolveProjectDirectory, } from "./folders.js";
 import { ProjectOperationError, } from "./contracts.js";
+function hasProjectDeleteTarget(value) {
+    if (typeof value !== "string")
+        return false;
+    return value.trim().length > 0;
+}
 export function createRuntimeProjectService(config, sessions) {
     const repository = new FileProjectRepository(join(config.paths.runtimeDir, "projects", "registry.json"));
     const get = async (id) => (await repository.list()).find((project) => project.id === id) ?? null;
     return Object.freeze({
         list: () => repository.list(),
+        catalog: () => repository.catalog(),
+        async delete(projectId) {
+            if (!hasProjectDeleteTarget(projectId))
+                throw new ProjectOperationError("project_id_required", "Select a project to delete.");
+            await repository.delete(projectId);
+        },
         get,
         async create(input) {
             const directory = await resolveProjectDirectory(input.directory);

package/dist/src/runtime/request/approval-wait/preflight.js

@@ -49,6 +49,7 @@ export async function validateApprovalResume(services, snapshot, current) {
             sessionStore: services.sessions,
             attachmentStore: services.attachments,
             toolRegistry: services.tools,
+            knowledgeSkillStore: services.knowledgeSkillStore,
             modelGatewayClient: models,
             eventSinkFactory: { create: () => events },
             sessionMemoryCompactor: services.sessionMemoryCompactor,
@@ -73,6 +74,7 @@ export async function validateApprovalResume(services, snapshot, current) {
                 rawAttachments: [],
                 rawAgentMode: snapshot.seed.agentMode,
                 rawModelPreference: snapshot.seed.modelPreference,
+                rawReasoningPreference: snapshot.seed.reasoningPreference,
                 toolPermissionMode: snapshot.seed.toolPermissionMode,
             },
             temporalContext: snapshot.seed.temporalContext ?? captureRequestTemporalContext(),

package/dist/src/runtime/request/approval-wait/snapshot.d.ts

@@ -11,7 +11,7 @@ import type { RequestToolResources } from "../../capabilities/request-tool-resou
 import type { RequestApprovalContinuation } from "../approval-continuation.js";
 export declare const REQUEST_APPROVAL_SNAPSHOT = "request_approval_snapshot_v1";
 /** Frozen data consumed by the existing request constructor; no service objects. */
-export type PersistedRequestSeed = Pick<RequestExecutionSeed, "requestId" | "sessionId" | "sessionKind" | "prompt" | "temporalContext" | "historyMessages" | "sessionArtifactPaths" | "shouldGenerateSessionTitle" | "runnerConfig" | "executionPolicySelection" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy" | "toolPermissionMode" | "memoryRecallLimit">;
+export type PersistedRequestSeed = Pick<RequestExecutionSeed, "requestId" | "sessionId" | "sessionKind" | "prompt" | "temporalContext" | "historyMessages" | "sessionArtifactPaths" | "shouldGenerateSessionTitle" | "runnerConfig" | "executionPolicySelection" | "attachments" | "agentMode" | "modelPreference" | "reasoningPreference" | "modelPolicy" | "toolPermissionMode" | "memoryRecallLimit">;
 export type RequestApprovalSnapshot = Readonly<{
     kind: typeof REQUEST_APPROVAL_SNAPSHOT;
     originalPrompt: string;

package/dist/src/runtime/request/approval-wait/snapshot.js

@@ -15,6 +15,7 @@ export function snapshotRequestSeed(seed) {
         attachments: seed.attachments,
         agentMode: seed.agentMode,
         modelPreference: seed.modelPreference,
+        reasoningPreference: seed.reasoningPreference,
         modelPolicy: seed.modelPolicy,
         toolPermissionMode: seed.toolPermissionMode,
         memoryRecallLimit: seed.memoryRecallLimit,

package/dist/src/runtime/request/bound-runtime-handler.js

@@ -7,6 +7,7 @@ export function createBoundRuntimeRequestHandler(services) {
         sessionStore: services.sessions,
         attachmentStore: services.attachments,
         toolRegistry: services.tools,
+        knowledgeSkillStore: services.knowledgeSkillStore,
         sessionMemoryCompactor: services.sessionMemoryCompactor,
         longTermMemory: services.longTermMemory,
     };

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

@@ -1,3 +1,5 @@
+import type { ModelReasoningPreference } from "../../shared/model-reasoning.js";
+import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
 import type { RequestToolResources } from "../capabilities/request-tool-resources.js";
 import type { CapabilityApprovalGate } from "../orchestration/worker-capabilities/approval-contracts.js";
 import type { RequestApprovalExecution } from "./approval-wait/snapshot.js";
@@ -28,6 +30,7 @@ export type RunRequestMessage = {
     text?: string;
     agentMode?: unknown;
     modelPreference?: unknown;
+    reasoningPreference?: unknown;
     toolPermissionMode?: unknown;
     attachments?: unknown;
 };
@@ -44,6 +47,7 @@ export type RequestHandlerOptions = {
     sessionStore?: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
     toolRegistry?: ToolRegistry;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     toolApprovalController?: ToolApprovalController;
     requestSteering?: RequestSteeringInbox;
     /** Trusted automation-only receipt boundary; never accepted from client JSON. */
@@ -77,6 +81,7 @@ export type RequestExecutionSeed = Readonly<{
     attachments?: ModelGatewayAttachment[];
     agentMode: AgentMode;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     modelGatewayClient: Pick<ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
     contextCompactionStore?: RequestContextCompactionStore;
@@ -126,6 +131,7 @@ export type RequestModelRuntime = Readonly<{
     modelInvocationScope?: RequestExecutionSeed["modelInvocationScope"];
     runnerConfig: RequestExecutionSeed["runnerConfig"];
     modelPreference?: RequestExecutionSeed["modelPreference"];
+    reasoningPreference?: RequestExecutionSeed["reasoningPreference"];
     modelPolicy?: RequestExecutionSeed["modelPolicy"];
     modelGatewayClient: RequestExecutionSeed["modelGatewayClient"];
 }>;
@@ -153,7 +159,7 @@ export type RequestPresentation = Readonly<{
     onAnswerToken: RequestExecutionSeed["onAnswerToken"];
 }>;
 /** The exact request-owned surface required by model invocation. */
-export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "toolResources" | "modelInvocationScope" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
+export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "toolResources" | "modelInvocationScope" | "runnerConfig" | "agentMode" | "modelPreference" | "reasoningPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
 /**
  * Nominal marker for a request that already owns its single model-step port.
  * It is non-enumerable on canonical request views, so it cannot enter model or

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

@@ -40,6 +40,7 @@ export function createRequestSeedFacets(seed) {
             ? { modelInvocationScope: seed.modelInvocationScope }
             : {}),
         runnerConfig: seed.runnerConfig,
+        ...(seed.reasoningPreference ? { reasoningPreference: seed.reasoningPreference } : {}),
         ...(seed.modelPreference !== undefined
             ? { modelPreference: seed.modelPreference }
             : {}),
@@ -101,6 +102,7 @@ export function createModelInvocationView(facets) {
         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),

package/dist/src/runtime/request/execution-payload-artifact-policy.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/index.js";
+/** The frozen request policy owns implicit payload evidence collection. */
+export declare function allowsAutomaticPayloadArtifactLoading(authority: ExecutionPolicyAuthoritySnapshot | undefined): boolean;

package/dist/src/runtime/request/execution-payload-artifact-policy.js

@@ -0,0 +1,6 @@
+/** The frozen request policy owns implicit payload evidence collection. */
+export function allowsAutomaticPayloadArtifactLoading(authority) {
+    if (authority?.id === "execution-agent-v1")
+        return false;
+    return true;
+}

package/dist/src/runtime/request/execution-payload-compacted-evidence.d.ts

@@ -25,9 +25,9 @@ export declare function projectExecutionPayloadCompactedEvidence(request: Payloa
         summary: string;
         capabilityId: string;
         callId: string;
-        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
-        executionId: string;
         invocationAttempt: number;
+        executionId: string;
+        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
         observedEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityObservedEffect;
         declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityDeclaredEffect;
         references?: readonly import("../orchestration/role-calls/contracts.js").RoleCapabilityResultReference[];

package/dist/src/runtime/request/execution-payload-compacted-evidence.js

@@ -12,6 +12,7 @@ export function projectExecutionPayloadCompactedEvidence(request, context, resul
         prompt: request.prompt,
         objective: projectExecutionCompactionObjective(request.prompt, context.root.updates),
         callId: context.root.callId,
+        updates: context.root.updates,
         store: request.contextCompactionStore,
         results,
     });

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

@@ -1,4 +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";
@@ -12,5 +14,7 @@ export declare function createScopeSurface(input: Readonly<{
     modelInvocation: RequestModelInvocationView;
     modelSteps: RequestModelStepPort;
     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),
@@ -34,7 +35,13 @@ export function createCapabilityCompositionView(facets, modelSteps) {
         modelSteps: enumerableGetter(() => modelSteps),
         sessionId: enumerableGetter(() => facets.identity.sessionId),
         prompt: enumerableGetter(() => facets.input.prompt),
+        ...(facets.input.attachments !== undefined
+            ? { attachments: enumerableGetter(() => facets.input.attachments) }
+            : {}),
         historyMessages: enumerableGetter(() => facets.session.historyMessages),
+        ...(facets.session.sessionMemory !== undefined
+            ? { sessionMemory: enumerableGetter(() => facets.session.sessionMemory) }
+            : {}),
         toolPermissionMode: enumerableGetter(() => facets.lifecycle.toolPermissionMode),
         ...(facets.lifecycle.toolApprovalController !== undefined
             ? {
@@ -107,6 +114,8 @@ 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
             ? {
                 superFailureFinalization: hiddenValue(input.superFailureFinalization),
@@ -160,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

@@ -1,11 +1,14 @@
+import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
+import type { AvailableSkillsSource } from "../knowledge-skills/available-skills.js";
 import { type RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import { type SuperFailureFinalization } from "./super-failure-explanation.js";
 import type { ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 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" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
+export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "sessionMemory" | "attachments" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
 /**
  * Stable request-owned context delivered to capability adapters.
  * Passive session artifact paths and request containers are excluded.
@@ -13,7 +16,7 @@ export type RequestCapabilityCompositionView = BoundRequestModelInvocationContex
 export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory" | "memoryRecallLimit" | "scheduledExecution">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
     filesystemScope?: RuntimeFilesystemScope;
-    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
+    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource & AvailableSkillsSource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
 export type RequestExecutionPolicyFacet = Readonly<{
@@ -35,12 +38,15 @@ export type RequestExecutionScope = RequestExecutionSeed & BoundRequestModelInvo
     capabilities: RequestWorkerCapabilities;
     superFailureFinalization?: SuperFailureFinalization;
     workerCapabilities: RequestWorkerCapabilities;
+    knowledgeSkillStore?: KnowledgeSkillStore;
+    supervisorSkillSelectionWindows: SupervisorSkillSelectionWindows;
 }>;
 export type CompiledRequestExecutionPolicy = RequestExecutionScope["executionPolicy"];
 export type RequestWorkerCapabilityProviderSource = Pick<RequestExecutionScope, "workerCapabilities">;
 export type RequestWorkerCapabilityCatalog = Pick<WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>, "getDescriptors" | "getExecutionGuidance">;
 export declare function createRequestExecutionScope(input: Readonly<{
     seed: RequestExecutionSeed;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     requestWorkingDirectory?: string;
     executionPolicy: CompiledRequestExecutionPolicy;
     superFailureFinalization?: SuperFailureFinalization;

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

@@ -1,8 +1,12 @@
+import { matchesToolSelectionId } from "../../shared/tool-selection.js";
+import { CORE_TOOL_CONTRACTS } from "../capabilities/core-tool-contracts.js";
+import { captureModelPluginConfig } from "../config/model-plugin-config.js";
 import { captureRuntimeFilesystemScope, } from "../context/runtime-filesystem-scope.js";
 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);
@@ -22,6 +26,10 @@ export function createRequestExecutionScope(input) {
         modelInvocation,
         modelSteps,
         capabilities,
+        supervisorSkillSelectionWindows: createSupervisorSkillSelectionWindows(),
+        ...(input.knowledgeSkillStore && !isSkillStoreDeniedForModel(input.seed)
+            ? { knowledgeSkillStore: input.knowledgeSkillStore }
+            : {}),
         superFailureFinalization: input.superFailureFinalization ??
             createSuperFailureFinalization({
                 request: input.seed,
@@ -44,3 +52,8 @@ function createRequestExecutionPolicyFacet(selection, executionPolicy) {
         executionPolicy,
     });
 }
+/** Direct core reads retain the same captured model restriction as abot_skills. */
+function isSkillStoreDeniedForModel(seed) {
+    const deniedSelectors = captureModelPluginConfig(seed.executionPolicySelection?.plugins)?.deny ?? [];
+    return deniedSelectors.some((selector) => matchesToolSelectionId("", CORE_TOOL_CONTRACTS.skills.name, selector));
+}

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/payload-settled-evidence.d.ts

@@ -0,0 +1,11 @@
+import { type SemanticCompactionSource } from "../context/semantic-compaction/contracts.js";
+import type { projectExecutionPayloadCompactedEvidence } from "./execution-payload-compacted-evidence.js";
+type PayloadSettledResult = ReturnType<typeof projectExecutionPayloadCompactedEvidence>["results"][number];
+/** Keep the adapter envelope exact and the pre-projection compaction identity stable. */
+export declare function projectPayloadSettledEvidence(results: readonly PayloadSettledResult[]): Readonly<{
+    results: readonly PayloadSettledResult[];
+    resultSourceOverrides: readonly SemanticCompactionSource[];
+    deduplicatedReferenceDataCount: number;
+    deduplicatedReferenceDataChars: number;
+}>;
+export {};

package/dist/src/runtime/request/payload-settled-evidence.js

@@ -0,0 +1,29 @@
+import { findExactEvidencePath } from "../context/exact-evidence-match.js";
+import { createSemanticCompactionSha256Fingerprint, } from "../context/semantic-compaction/contracts.js";
+/** Keep the adapter envelope exact and the pre-projection compaction identity stable. */
+export function projectPayloadSettledEvidence(results) {
+    const resultSourceOverrides = [];
+    let deduplicatedReferenceDataChars = 0;
+    const projected = results.map((result) => {
+        if (!("adapterResult" in result) || !result.referenceData)
+            return result;
+        const representedAt = findExactEvidencePath(result.adapterResult, result.referenceData);
+        if (!representedAt)
+            return result;
+        deduplicatedReferenceDataChars += result.referenceData.length;
+        const content = JSON.stringify(result);
+        resultSourceOverrides.push(Object.freeze({
+            sourceRef: `payload-result:${result.executionId}`,
+            sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+            content,
+        }));
+        const { referenceData: _referenceData, ...singleCopyResult } = result;
+        return Object.freeze(singleCopyResult);
+    });
+    return Object.freeze({
+        results: Object.freeze(projected),
+        resultSourceOverrides: Object.freeze(resultSourceOverrides),
+        deduplicatedReferenceDataCount: resultSourceOverrides.length,
+        deduplicatedReferenceDataChars,
+    });
+}

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 }
             : {}),
@@ -211,6 +214,7 @@ export async function prepareRequestExecution(params) {
     resources.assertRestoredStateClaimed();
     const request = createRequestExecutionScope({
         seed,
+        ...(options.knowledgeSkillStore ? { knowledgeSkillStore: options.knowledgeSkillStore } : {}),
         requestWorkingDirectory,
         executionPolicy,
         ...(superFailureFinalization ? { superFailureFinalization } : {}),
@@ -227,6 +231,7 @@ export async function prepareRequestExecution(params) {
                 ? { runtimeConfig: options.runtimeConfig }
                 : {}),
             ...(toolRegistry ? { toolRegistryOverride: toolRegistry } : {}),
+            knowledgeSkillStore: options.knowledgeSkillStore,
         }),
     });
     return {

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/role-call-delegation-events.d.ts

@@ -0,0 +1,19 @@
+import type { RoleCallLedger, RoleCallLedgerCommit } from "../orchestration/role-calls/index.js";
+import { type RuntimeDelegateRoleId } from "../orchestration/roles.js";
+export type RequestRoleDelegationEvent = Readonly<{
+    name: "role.delegated";
+    payload: Readonly<{
+        callerCallId: string;
+        callerRole: "supervisor";
+        childCallId: string;
+        childRole: RuntimeDelegateRoleId;
+        objective: string;
+    }>;
+}>;
+/** Projects the accepted assignment without changing role state or active stage. */
+export declare function projectRequestRoleDelegationCommit(commit: RoleCallLedgerCommit): RequestRoleDelegationEvent | undefined;
+/** Uses the existing synchronous commit boundary, including emission faults. */
+export declare function attachRequestRoleDelegationEvents(params: Readonly<{
+    ledger: RoleCallLedger;
+    onEvent(name: string, payload: Record<string, unknown>): void;
+}>): void;

package/dist/src/runtime/request/role-call-delegation-events.js

@@ -0,0 +1,52 @@
+import { consumeUnexpectedThenable } from "../orchestration/synchronous-boundary.js";
+import { isRuntimeDelegateRoleId, } from "../orchestration/roles.js";
+/** Projects the accepted assignment without changing role state or active stage. */
+export function projectRequestRoleDelegationCommit(commit) {
+    if (!isDirectSupervisorChildOpen(commit))
+        return undefined;
+    const child = commit.head.state.calls.find((call) => call.callId === commit.effect.childCallId);
+    if (!isDirectSupervisorChild(child, commit.effect.callerCallId))
+        return undefined;
+    return Object.freeze({
+        name: "role.delegated",
+        payload: Object.freeze({
+            callerCallId: commit.effect.callerCallId,
+            callerRole: "supervisor",
+            childCallId: child.callId,
+            childRole: child.roleId,
+            objective: child.objective,
+        }),
+    });
+}
+/** Uses the existing synchronous commit boundary, including emission faults. */
+export function attachRequestRoleDelegationEvents(params) {
+    params.ledger.commits.subscribe((commit) => {
+        const event = projectRequestRoleDelegationCommit(commit);
+        if (!event)
+            return;
+        const emitted = Reflect.apply(params.onEvent, undefined, [
+            event.name,
+            event.payload,
+        ]);
+        if (consumeUnexpectedThenable(emitted))
+            throw new TypeError("Request delegation event sink must be synchronous.");
+    });
+}
+function isDirectSupervisorChildOpen(commit) {
+    if (commit.effect.type !== "child_opened")
+        return false;
+    if (commit.head.policy.authority.rootContractId !== "supervisor")
+        return false;
+    return commit.effect.callerCallId === commit.head.state.rootCallId;
+}
+function isDirectSupervisorChild(child, callerCallId) {
+    if (!child)
+        return false;
+    if (child.parentCallId !== callerCallId)
+        return false;
+    if (child.depth !== 1)
+        return false;
+    if (!isRuntimeDelegateRoleId(child.roleId))
+        return false;
+    return typeof child.objective === "string";
+}

package/dist/src/runtime/request/role-call-return-events.d.ts

@@ -0,0 +1,19 @@
+import { type RoleCallLedger, type RoleCallLedgerCommit } from "../orchestration/role-calls/index.js";
+export type RequestRoleReturnEvent = Readonly<{
+    name: "role.returned";
+    payload: Readonly<{
+        callerCallId: string;
+        callerRole: "supervisor";
+        childCallId: string;
+        childRole: "planner";
+        outcome: "completed" | "failed";
+        summary: string;
+    }>;
+}>;
+/** Projects the stored Planner result without changing role state or active stage. */
+export declare function projectRequestRoleReturnCommit(commit: RoleCallLedgerCommit): RequestRoleReturnEvent | undefined;
+/** Uses the existing synchronous commit boundary, including emission faults. */
+export declare function attachRequestRoleReturnEvents(params: Readonly<{
+    ledger: RoleCallLedger;
+    onEvent(name: string, payload: Record<string, unknown>): void;
+}>): void;