@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/request/super-payload-context-failure.js

@@ -3,6 +3,9 @@ import { hasSuperContextContract } from "../context/super-context-policy.js";
 import { validateRoleCallCandidate } from "../orchestration/role-calls/reducer.js";
 import { quarantineProvenOwnedSuperCheckpoint } from "./super-checkpoint-quarantine.js";
 import { traceDebug } from "../observability/debug-logger.js";
+import { isCanonicalSuperCapabilitySourceCall } from "../context/capability-result-compaction-source.js";
+import { superPayloadCompactionContractId } from "../context/super-worker-compaction-sidecar.js";
+import { rootPayloadCompactionScopeId } from "../orchestration/worker-capabilities/payload-compaction-transport.js";
 /** Preserve normal failed-capability settlement; never create a role commit here. */
 export function quarantineOwnedSuperPayloadCheckpoint(request, input, error) {
     if (request.abortSignal.aborted || !(error instanceof SuperContextFailure))
@@ -11,10 +14,13 @@ export function quarantineOwnedSuperPayloadCheckpoint(request, input, error) {
     if (!sidecar || !request.contextCompactionStore)
         return;
     const head = sidecar.head;
-    if (!hasSuperContextContract(head.policy.authority, "delegated.worker"))
+    const contractId = superPayloadCompactionContractId(sidecar);
+    if (!hasSuperContextContract(head.policy.authority, contractId))
         return;
     const call = head.state.calls.find((candidate) => candidate.callId === sidecar.callId);
-    if (!call || call.roleId !== "worker" || call.status !== "active")
+    if (!isCanonicalSuperCapabilitySourceCall(head, call))
+        return;
+    if (call.status !== "active")
         return;
     if (head.state.phase !== "running" || head.state.activeCallId !== call.callId)
         return;
@@ -28,12 +34,15 @@ export function quarantineOwnedSuperPayloadCheckpoint(request, input, error) {
     if (binding.requestId !== request.requestId || binding.callId !== call.callId)
         return;
     if (binding.parentCallId !== call.parentCallId ||
-        binding.contractId !== "delegated.worker")
+        binding.contractId !== contractId)
         return;
     if (binding.sourceRevision !== head.revision ||
         binding.invocationAttempt !== call.activationCount)
         return;
-    if (binding.scopeId !== `worker:${call.callId}:request-tool-results` ||
+    const scopeId = "worker" in input.context
+        ? `worker:${call.callId}:request-tool-results`
+        : rootPayloadCompactionScopeId(input);
+    if (binding.scopeId !== scopeId ||
         binding.modelStep !== input.modelStep)
         return;
     if (validateRoleCallCandidate({ state: head.state, policy: head.policy }).length)

package/dist/src/runtime/request/supervisor-root-execution.js

@@ -1,3 +1,7 @@
+import { canRootReadSkills } from "./root-skill-read.js";
+import { isSupervisorSkillWriteCapabilityId } from "../orchestration/worker-capabilities/supervisor-skill-authority.js";
+import { isSupervisorSkillWriteSelection } from "../steps/supervisor-skill-authoring/contract.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
 import { projectSupervisorCallIdentity, projectSupervisorResumeContext, runSupervisorDecision, SUPERVISOR_DECISION_MODEL_STEP, } from "../steps/supervisor-decision/index.js";
 import { runSupervisorAuthoredResponse, SUPERVISOR_RESPONSE_MODEL_STEP, } from "../steps/supervisor-response/index.js";
 import { runRootExecutionKernel, } from "./root-execution-kernel.js";
@@ -9,14 +13,26 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
     projectCallIdentity: projectSupervisorCallIdentity,
     projectResume: projectSupervisorResumeContext,
     async decide(request, options) {
-        return runSupervisorDecision(request, {
+        if (hasSettledSupervisorSkillWrite(options.head))
+            return {
+                decision: { action: "respond" },
+                steeringVersion: resolveRequestSteeringInbox(request.requestSteering).snapshot().version,
+            };
+        const outcome = await runSupervisorDecision(request, {
             call: options.call,
+            skillReadHead: options.head,
             memoryRecallCount: options.head.state.memoryRecalls.length,
+            allowSkillReads: canRootReadSkills(request, options.head, options.callFrame),
+            remainingRoleCalls: options.head.policy.limits.maxCalls -
+                options.head.state.calls.length,
+            remainingCapabilityExecutions: options.head.policy.limits.maxCapabilityExecutions -
+                options.head.state.capabilityExecutions.length,
             toolResults: options.toolResults,
             includeAcknowledgement: options.includeAcknowledgement,
             includeTitle: options.includeTitle,
             allowedRoleIds: options.allowedRoleIds,
             availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+            availableSkillWriteOperationIds: options.availableSkillWriteOperationIds,
             ...(options.head.state.initialMemory?.message
                 ? { initialMemoryMessage: options.head.state.initialMemory.message }
                 : {}),
@@ -25,11 +41,32 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
                 : {}),
             ...(options.resume ? { resume: options.resume } : {}),
         });
+        const { decision, steeringVersion } = outcome;
+        if (decision.action === "no_save")
+            return {
+                steeringVersion, decision: {
+                    action: "respond", responseRecommendation: decision.reason,
+                    responseRecommendationOrigin: "skill_authoring_no_save",
+                    ...(decision.acknowledgement ? { acknowledgement: decision.acknowledgement } : {}),
+                    ...(decision.title ? { title: decision.title } : {}),
+                },
+            };
+        if (!isSupervisorSkillWriteSelection(decision))
+            return { decision, steeringVersion };
+        return {
+            steeringVersion, decision: {
+                action: "prepare_skill_write", selection: decision,
+                ...(decision.acknowledgement ? { acknowledgement: decision.acknowledgement } : {}),
+                ...(decision.title ? { title: decision.title } : {}),
+            },
+        };
     },
     async authorResponse(request, options) {
         return runSupervisorAuthoredResponse(request, {
             responseRecommendation: options.responseRecommendation,
+            responseRecommendationOrigin: options.responseRecommendationOrigin,
             call: options.call,
+            skillReadHead: options.head,
             toolResults: options.toolResults,
             ...(options.head.state.initialMemory?.message
                 ? { initialMemoryMessage: options.head.state.initialMemory.message }
@@ -42,6 +79,16 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
         });
     },
 });
+/** A settled write is terminal even after approval restoration; pending writes stay pending. */
+function hasSettledSupervisorSkillWrite(head) {
+    return head.state.capabilityExecutions.some((execution) => {
+        if (execution.callId !== head.state.rootCallId)
+            return false;
+        if (execution.status !== "settled")
+            return false;
+        return isSupervisorSkillWriteCapabilityId(execution.capabilityId);
+    });
+}
 /** Executes the Supervisor root contract for an already composed request. */
 export async function runSupervisorRootExecution(params) {
     return runRootExecutionKernel({

package/dist/src/runtime/request/supervisor-skill-edit-target.d.ts

@@ -0,0 +1,9 @@
+import type { KnowledgeSkillDocument } from "../knowledge-skills/store.js";
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+type PersonalEditTarget = KnowledgeSkillDocument & Readonly<{
+    source: "personal";
+    revision: number;
+}>;
+/** Resolve the captured document, never a newer Store value, for one accepted edit. */
+export declare function findCapturedPersonalSkillEditTarget(head: RoleCallLedgerHead, skillId: string, expectedRevision?: number): PersonalEditTarget | undefined;
+export {};

package/dist/src/runtime/request/supervisor-skill-edit-target.js

@@ -0,0 +1,25 @@
+/** Resolve the captured document, never a newer Store value, for one accepted edit. */
+export function findCapturedPersonalSkillEditTarget(head, skillId, expectedRevision) {
+    for (const read of [...(head.state.skillReads ?? [])].reverse()) {
+        if (read.callId !== head.state.rootCallId)
+            continue;
+        if (read.operation !== "read_skills" || read.result.outcome !== "completed")
+            continue;
+        const document = read.result.skills.find((candidate) => candidate.skillId === skillId);
+        if (!document)
+            continue;
+        if (!isPersonalEditTarget(document))
+            return undefined;
+        if (expectedRevision !== undefined && document.revision !== expectedRevision)
+            return undefined;
+        return document;
+    }
+    return undefined;
+}
+function isPersonalEditTarget(document) {
+    if (document.source !== "personal")
+        return false;
+    if (!Number.isSafeInteger(document.revision))
+        return false;
+    return (document.revision ?? 0) >= 1;
+}

package/dist/src/runtime/request/supervisor-skill-payload-context.d.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage, ModelGatewayAttachment } from "../../model-gateway/types.js";
+import type { RequestContextPinnedPart } from "../context/request-context-contracts.js";
+import type { WorkerCapabilityPayloadAuthor, WorkerCapabilityPayloadModelRequest } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { RequestExecutionSeed } from "./contracts.js";
+import { type RootSessionMemoryProjection } from "../context/session-memory/root-projection.js";
+import { createSessionMemoryAwareCompactionController } from "../context/session-memory/model-step-controller.js";
+import type { ModelStepContextCompactionController } from "../model/model-step-port.js";
+type PayloadAuthorInput = Parameters<WorkerCapabilityPayloadAuthor["author"]>[0];
+/** The accepted edit uses the exact captured revision, never a fresh Store read. */
+export declare function prepareSupervisorSkillPayloadInput(input: PayloadAuthorInput): PayloadAuthorInput;
+export declare function projectPayloadSkillGuidance(input: WorkerCapabilityPayloadModelRequest): readonly ChatMessage[];
+/** Keep child evidence compactable while the full replacement target stays exact. */
+export declare function projectSupervisorSkillPayloadContinuation(input: WorkerCapabilityPayloadModelRequest, targetContentMessage: ChatMessage | undefined): Readonly<{
+    continuationParts?: readonly RequestContextPinnedPart[];
+    continuationMessages?: readonly ChatMessage[];
+}>;
+export declare function projectSupervisorSkillPayloadRequestSource(input: WorkerCapabilityPayloadModelRequest, message: ChatMessage, attachments: ModelGatewayAttachment[] | undefined): ChatMessage;
+/** Conversation remains in its existing history lane, before budgeting. */
+export declare function projectSupervisorSkillPayloadHistory(input: WorkerCapabilityPayloadModelRequest, request: Pick<RequestExecutionSeed, "historyMessages" | "sessionMemory">): RootSessionMemoryProjection | undefined;
+export declare function createSupervisorSkillPayloadCompactionController(input: WorkerCapabilityPayloadModelRequest, request: Parameters<typeof createSessionMemoryAwareCompactionController>[0], activeRequestController: ModelStepContextCompactionController): ModelStepContextCompactionController;
+export {};

package/dist/src/runtime/request/supervisor-skill-payload-context.js

@@ -0,0 +1,91 @@
+import { buildCoreSkillReadContextMessages } from "../context/core-skill-read-context.js";
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { readSuperWorkerCompactionSidecar, } from "../context/super-worker-compaction-sidecar.js";
+import { isSupervisorSkillWriteCapabilityId } from "../orchestration/worker-capabilities/supervisor-skill-authority.js";
+import { buildCompletedSupervisorChildContinuationParts } from "../steps/supervisor-decision/resume.js";
+import { findCapturedPersonalSkillEditTarget } from "./supervisor-skill-edit-target.js";
+import { projectRootSessionMemory } from "../context/session-memory/root-projection.js";
+import { createSessionMemoryAwareCompactionController } from "../context/session-memory/model-step-controller.js";
+/** The accepted edit uses the exact captured revision, never a fresh Store read. */
+export function prepareSupervisorSkillPayloadInput(input) {
+    const sidecar = readSuperWorkerCompactionSidecar(input.settledCapabilityResults);
+    if (!isSupervisorSkillOwner(sidecar, input.call.callId, input.descriptor.capabilityId))
+        return input;
+    if (input.descriptor.capabilityId !== "update_skill")
+        return input;
+    const document = typeof input.controls.skillId === "string" && typeof input.controls.expectedRevision === "number"
+        ? findCapturedPersonalSkillEditTarget(sidecar.head, input.controls.skillId, input.controls.expectedRevision)
+        : undefined;
+    if (!document)
+        throw new Error("supervisor_skill_edit_target_revision_mismatch");
+    return Object.freeze({
+        ...input,
+        stage: Object.freeze({ index: 1, count: 1, outputParam: "content" }),
+        targetContext: Object.freeze({
+            targetParam: "skillId", targetPath: document.skillId,
+            presentation: "full", content: document.content,
+        }),
+    });
+}
+export function projectPayloadSkillGuidance(input) {
+    if (input.context.contextScope !== "standard")
+        return [];
+    const messages = buildCoreSkillReadContextMessages(input.superWorkerCompaction?.head, "delegate");
+    if (!isSupervisorSkillPayload(input) || input.context.acceptedCapability.capabilityId !== "update_skill")
+        return messages;
+    const targetId = input.context.targetContext?.targetPath;
+    return messages.filter(({ content }) => JSON.parse(content).document?.skillId !== targetId);
+}
+/** Keep child evidence compactable while the full replacement target stays exact. */
+export function projectSupervisorSkillPayloadContinuation(input, targetContentMessage) {
+    if (!isSupervisorSkillPayload(input))
+        return targetContentMessage
+            ? { continuationMessages: [targetContentMessage] } : {};
+    const parts = [
+        ...buildCompletedSupervisorChildContinuationParts(input.superWorkerCompaction?.head),
+    ];
+    if (targetContentMessage)
+        parts.push(Object.freeze({
+            sourceRef: `supervisor-skill-edit-target:${input.executionId}`,
+            category: "role_continuation", retention: "exact",
+            messages: Object.freeze([targetContentMessage]),
+        }));
+    return parts.length ? { continuationParts: Object.freeze(parts) } : {};
+}
+export function projectSupervisorSkillPayloadRequestSource(input, message, attachments) {
+    if (!isSupervisorSkillPayload(input) || !attachments?.length)
+        return message;
+    return { role: "user", content: message.content, attachments };
+}
+/** Conversation remains in its existing history lane, before budgeting. */
+export function projectSupervisorSkillPayloadHistory(input, request) {
+    if (!usesSupervisorSkillRequestHistory(input))
+        return undefined;
+    return projectRootSessionMemory(request);
+}
+export function createSupervisorSkillPayloadCompactionController(input, request, activeRequestController) {
+    if (!usesSupervisorSkillRequestHistory(input))
+        return activeRequestController;
+    return createSessionMemoryAwareCompactionController(request, activeRequestController);
+}
+function usesSupervisorSkillRequestHistory(input) {
+    if (input.requestSourceProjection !== "full_request")
+        return false;
+    return isSupervisorSkillPayload(input);
+}
+function isSupervisorSkillPayload(input) {
+    if (!("root" in input.context) || input.context.contextScope !== "standard")
+        return false;
+    return isSupervisorSkillOwner(input.superWorkerCompaction, input.context.root.callId, input.context.acceptedCapability.capabilityId);
+}
+function isSupervisorSkillOwner(sidecar, callId, capabilityId) {
+    if (!sidecar || !isSupervisorSkillWriteCapabilityId(capabilityId))
+        return false;
+    const { head } = sidecar;
+    if (!hasSuperContextContract(head.policy.authority, "supervisor"))
+        return false;
+    if (sidecar.callId !== callId || sidecar.parentCallId !== null || head.state.rootCallId !== callId)
+        return false;
+    const call = head.state.calls.find((candidate) => candidate.callId === callId);
+    return call?.roleId === "supervisor" && call.parentCallId === null && call.depth === 0;
+}

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/supervisor-skill-write-preparation.d.ts

@@ -0,0 +1,25 @@
+import type { RoleCallLedger, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
+import type { RootContractDecision } from "./root-contract.js";
+import type { RootDecisionActivation } from "./root-execution-contracts.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+type WritePreparationDecision = Extract<RootContractDecision, {
+    action: "prepare_skill_write";
+}>;
+type PreparedActivation = RootDecisionActivation & Readonly<{
+    decision: Extract<RootContractDecision, {
+        action: "invoke_capability" | "respond";
+    }>;
+}>;
+/** Prepare the already selected write without returning to routing or discovery. */
+export declare function prepareSupervisorSkillWrite(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    activation: RootDecisionActivation & Readonly<{
+        decision: WritePreparationDecision;
+    }>;
+    resume: RoleChildReturnContext | undefined;
+}): Promise<Readonly<{
+    activation: PreparedActivation;
+    resume: RoleChildReturnContext | undefined;
+}> | undefined>;
+export {};

package/dist/src/runtime/request/supervisor-skill-write-preparation.js

@@ -0,0 +1,71 @@
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { performRootReferenceAction } from "./root-reference-action.js";
+import { canRootReadSkills } from "./root-skill-read.js";
+import { findCapturedPersonalSkillEditTarget } from "./supervisor-skill-edit-target.js";
+const SKILL_DOCUMENT_ASSIGNMENT = "Produce only the complete reusable Markdown Skill document requested by the user. Transform the supplied sources into guidance; do not copy the request, runtime instructions, or context envelopes. For an edit, preserve content outside the requested changes.";
+/** Prepare the already selected write without returning to routing or discovery. */
+export async function prepareSupervisorSkillWrite(params) {
+    const { request, ledger } = params;
+    let { activation, resume } = params;
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(activation.decisionSteeringVersion))
+        return undefined;
+    if (!isSupervisorWritePreparation(activation))
+        throw new Error("supervisor_skill_authority_invalid");
+    const selection = activation.decision.selection;
+    if (selection.action === "create_skill") {
+        return { activation: prepareInvocation(activation, { name: selection.name, description: selection.description }), resume };
+    }
+    let target = findCapturedPersonalSkillEditTarget(activation.head, selection.skillId);
+    if (!target) {
+        if (!canRootReadSkills(request, activation.head, activation.call)) {
+            return { activation: prepareNoSave(activation, "The requested Skill edit could not load its exact target within the request budget."), resume };
+        }
+        resume = await performRootReferenceAction(request, ledger, {
+            ...activation,
+            decision: { action: "read_skills", skillIds: [selection.skillId] },
+        }, resume);
+        request.abortSignal.throwIfAborted();
+        if (!steering.isCurrent(activation.decisionSteeringVersion))
+            return undefined;
+        const head = ledger.current();
+        const callIdentity = request.executionPolicy.rootContract.projectCallIdentity(head);
+        const call = head.state.calls.find(({ callId }) => callId === callIdentity.callId);
+        if (!call)
+            throw new Error("supervisor_call_frame_missing");
+        activation = { ...activation, head, call, callIdentity };
+        target = findCapturedPersonalSkillEditTarget(head, selection.skillId);
+    }
+    if (!target) {
+        return { activation: prepareNoSave(activation, "No Skill was saved: the selected exact personal Skill is unavailable or read-only."), resume };
+    }
+    return {
+        activation: prepareInvocation(activation, {
+            skillId: target.skillId, expectedRevision: target.revision,
+            ...(selection.name !== undefined ? { name: selection.name } : {}),
+            ...(selection.description !== undefined ? { description: selection.description } : {}),
+        }), resume,
+    };
+}
+function isSupervisorWritePreparation(activation) {
+    if (!hasSuperContextContract(activation.head.policy.authority, "supervisor"))
+        return false;
+    if (activation.call.callId !== activation.head.state.rootCallId)
+        return false;
+    return activation.call.parentCallId === null;
+}
+function prepareInvocation(activation, controls) {
+    const selection = activation.decision.selection;
+    const title = selection.action === "create_skill" ? selection.name : selection.skillId;
+    return { ...activation, decision: {
+            action: "invoke_capability", capabilityId: selection.action,
+            intent: `${selection.action === "create_skill" ? "Create" : "Update"} Skill: ${title}`,
+            authoringObjective: SKILL_DOCUMENT_ASSIGNMENT, controls,
+        } };
+}
+function prepareNoSave(activation, reason) {
+    return { ...activation, decision: { action: "respond",
+            responseRecommendation: reason, responseRecommendationOrigin: "skill_authoring_no_save" } };
+}

package/dist/src/runtime/request/worker-capability-composition.d.ts

@@ -1,3 +1,5 @@
+import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
+import { type AvailableSkillsSource } from "../knowledge-skills/available-skills.js";
 import type { RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
 import type { RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
@@ -15,10 +17,11 @@ type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;
     toolRegistryOverride?: ToolRegistry;
+    knowledgeSkillStore?: KnowledgeSkillStore;
 }>;
 /**
  * Creates one lazy, request-scoped Worker capability source from declarative
  * role config and the neutral runtime Tool Registry.
  */
-export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & ToolAvailabilitySource;
+export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & ToolAvailabilitySource & AvailableSkillsSource;
 export {};

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

@@ -1,3 +1,5 @@
+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";
 import { createRegisteredToolWorkerCapabilityProvider } from "../adapters/registered-tool-worker-capabilities.js";
@@ -41,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 }
@@ -68,8 +71,10 @@ export function createRequestWorkerCapabilityProvider(params) {
             ? { effectPersistence: params.request.effectPersistence }
             : {}),
     });
+    const getAvailableTools = () => projectAvailableTools(getRequestToolRegistry().listNormalInvocations?.());
     return Object.freeze({
         ...provider,
-        getAvailableTools: () => projectAvailableTools(getRequestToolRegistry().listNormalInvocations?.()),
+        getAvailableTools,
+        getAvailableSkills: () => projectAvailableSkills(params.knowledgeSkillStore, getAvailableTools()),
     });
 }

package/dist/src/runtime/request/worker-capability-payload.d.ts

@@ -2,7 +2,7 @@ import { type RuntimeFilesystemScope } from "../context/runtime-filesystem-scope
 import { type WorkerCapabilityPayloadAuthor } from "../orchestration/worker-capabilities/index.js";
 import type { ExecutionPolicyCapabilityAuthority } from "../orchestration/role-calls/index.js";
 import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "./contracts.js";
-type RequestWorkerCapabilityPayloadContext = BoundRequestModelInvocationContext & Pick<RequestExecutionSeed, "prompt" | "historyMessages" | "onEvent" | "contextCompactionStore">;
+type RequestWorkerCapabilityPayloadContext = BoundRequestModelInvocationContext & Pick<RequestExecutionSeed, "prompt" | "historyMessages" | "sessionId" | "sessionMemory" | "attachments" | "onEvent" | "contextCompactionStore">;
 /** Binds the neutral payload-author port to one request's model boundary. */
 export declare function createRequestWorkerCapabilityPayloadAuthor(request: RequestWorkerCapabilityPayloadContext, capabilityAuthorities?: readonly ExecutionPolicyCapabilityAuthority[], filesystemScope?: RuntimeFilesystemScope): WorkerCapabilityPayloadAuthor;
 export {};

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

@@ -11,6 +11,9 @@ import { traceDebug } from "../observability/debug-logger.js";
 import { createWorkerCapabilityPayloadAuthor, workerCapabilityContextCompactionScopeId, WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS, WorkerCapabilityPayloadBudgetExceededError, WorkerCapabilityPayloadValidationError, } from "../orchestration/worker-capabilities/index.js";
 import { buildWorkerCapabilityPayloadRepairHint } from "./worker-capability-payload-prompts.js";
 import { projectExecutionPayloadCompactedEvidence } from "./execution-payload-compacted-evidence.js";
+import { projectPayloadSettledEvidence } from "./payload-settled-evidence.js";
+import { rootPayloadCompactionScopeId } from "../orchestration/worker-capabilities/payload-compaction-transport.js";
+import { prepareSupervisorSkillPayloadInput, projectSupervisorSkillPayloadHistory, createSupervisorSkillPayloadCompactionController, projectPayloadSkillGuidance, projectSupervisorSkillPayloadContinuation, projectSupervisorSkillPayloadRequestSource, } from "./supervisor-skill-payload-context.js";
 const PAYLOAD_TARGET_CONTENT_MESSAGE_KIND = "runtime_payload_target_content_v1";
 const PAYLOAD_RELATED_ARTIFACT_CONTENT_MESSAGE_KIND = "runtime_payload_related_artifact_content_v1";
 const WORKER_CAPABILITY_PAYLOAD_MAX_REPAIR_ATTEMPTS = 2;
@@ -34,7 +37,7 @@ export function createRequestWorkerCapabilityPayloadAuthor(request, capabilityAu
                         capabilities: [authorInput.descriptor],
                     })),
                 }),
-            }).author(authorInput);
+            }).author(prepareSupervisorSkillPayloadInput(authorInput));
         },
     });
 }
@@ -51,10 +54,10 @@ async function invokePayloadModel(request, input, filesystemMessage) {
             request,
             modelStep: input.modelStep,
             messages: projection.messages,
-            contextCompaction: createModelStepCompactionController(request, {
+            contextCompaction: createSupervisorSkillPayloadCompactionController(input, request, createModelStepCompactionController(request, {
                 consumer: input.modelStep,
                 hasVerifiedCompactedEvidence: projection.hasVerifiedCompactedEvidence,
-                call: payloadCompactionCall(request.prompt, input.context),
+                call: payloadCompactionCall(request.prompt, input),
                 sourceRevision: input.superWorkerCompaction?.sourceRevision ??
                     payloadCompactionSourceRevision(input.context),
                 ...(input.superWorkerCompaction
@@ -65,12 +68,9 @@ async function invokePayloadModel(request, input, filesystemMessage) {
                     : {}),
                 allowedConsumers: compactionOptions.allowedConsumers,
                 scopeId: compactionOptions.scopeId,
-                ...(compactionOptions.resultSourceOverrides
-                    ? {
-                        resultSourceOverrides: compactionOptions.resultSourceOverrides,
-                    }
-                    : {}),
-            }),
+                resultSourceOverrides: compactionOptions.resultSourceOverrides ??
+                    projection.resultSourceOverrides,
+            })),
             timeoutReason: "worker_capability_payload_timeout",
             ...(input.responseFormat ? { format: input.responseFormat } : {}),
             maxRepairAttempts: WORKER_CAPABILITY_PAYLOAD_MAX_REPAIR_ATTEMPTS,
@@ -156,13 +156,14 @@ function payloadMessages(request, input, filesystemMessage) {
             : {}),
         ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
     });
+    const conversation = projectSupervisorSkillPayloadHistory(input, request);
     const requestSource = input.requestSourceProjection === "full_request"
         ? projectRequestSource({
             requestId: request.requestId,
             prompt: request.prompt,
             modelStep: input.modelStep,
             callId,
-            historyMessages: request.historyMessages,
+            historyMessages: conversation ? [] : request.historyMessages,
         })
         : undefined;
     const projectedContext = projectPayloadContext(input.context, request);
@@ -183,16 +184,15 @@ function payloadMessages(request, input, filesystemMessage) {
     try {
         const messages = projectRequestContext({
             instructions: input.instructions,
-            historyMessages: [],
+            ...(conversation ?? { historyMessages: [] }),
             prompt: canonicalContext,
             referenceMessages: [
+                ...projectPayloadSkillGuidance(input),
                 ...(filesystemMessage ? [filesystemMessage] : []),
-                ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
+                ...(requestSource ? [projectSupervisorSkillPayloadRequestSource(input, buildRequestSourceMessage(requestSource), request.attachments)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
-            ...(projectedContext.targetContentMessage
-                ? { continuationMessages: [projectedContext.targetContentMessage] }
-                : {}),
+            ...projectSupervisorSkillPayloadContinuation(input, projectedContext.targetContentMessage),
             budget,
             diagnostic: {
                 requestId: request.requestId,
@@ -204,6 +204,7 @@ function payloadMessages(request, input, filesystemMessage) {
         }).messages;
         return Object.freeze({
             messages,
+            resultSourceOverrides: projectedContext.resultSourceOverrides,
             hasVerifiedCompactedEvidence(candidateMessages) {
                 if (projectedContext.reusedCompactedSourceCount === 0)
                     return false;
@@ -223,21 +224,20 @@ function payloadMessages(request, input, filesystemMessage) {
 function payloadContextCallId(context) {
     return "worker" in context ? context.worker.callId : context.root.callId;
 }
-function payloadCompactionCall(requestPrompt, context) {
-    return Object.freeze("worker" in context
-        ? {
-            roleId: "worker",
-            callId: context.worker.callId,
-            objective: context.worker.objective,
-        }
-        : {
-            roleId: "root",
-            callId: context.root.callId,
-            objective: [
-                requestPrompt,
-                ...context.root.updates.map(({ text }) => text),
-            ].join("\n"),
+function payloadCompactionCall(requestPrompt, input) {
+    const context = input.context;
+    if ("worker" in context)
+        return Object.freeze({
+            roleId: "worker", callId: context.worker.callId, objective: context.worker.objective,
         });
+    if (input.superWorkerCompaction)
+        return Object.freeze({
+            roleId: "supervisor", callId: context.root.callId, objective: requestPrompt,
+        });
+    return Object.freeze({
+        roleId: "root", callId: context.root.callId,
+        objective: [requestPrompt, ...context.root.updates.map(({ text }) => text)].join("\n"),
+    });
 }
 function payloadCompactionSourceRevision(context) {
     const invocationAttempt = "worker" in context
@@ -257,12 +257,10 @@ function payloadCompactionOptions(input) {
     }
     return Object.freeze({
         allowedConsumers: Object.freeze([input.modelStep]),
-        scopeId: [
-            "payload",
-            payloadContextCallId(input.context),
-            input.executionId,
-            input.context.payloadStage?.index ?? 0,
-        ].join(":"),
+        scopeId: rootPayloadCompactionScopeId(input),
+        ...(input.superWorkerCompaction
+            ? { resultSourceOverrides: input.superWorkerCompaction.sources }
+            : {}),
     });
 }
 function projectPayloadContext(context, request) {
@@ -275,13 +273,14 @@ function projectPayloadContext(context, request) {
         : (context.relatedArtifactContexts ?? []).map((artifact, index) => projectRelatedArtifactContext(artifact, index));
     const settledResultProjection = projectSettledResultsForPayload(context, contextScope);
     const compactedEvidence = projectExecutionPayloadCompactedEvidence(request, context, settledResultProjection.results);
+    const adapterEvidence = projectPayloadSettledEvidence(compactedEvidence.results);
     const baseMetadata = { ...context };
     delete baseMetadata.targetContext;
     delete baseMetadata.relatedArtifactContexts;
     return Object.freeze({
         metadata: Object.freeze({
             ...baseMetadata,
-            settledCapabilityResults: compactedEvidence.results,
+            settledCapabilityResults: adapterEvidence.results,
             ...(compactedEvidence.evidence
                 ? { compactedSourceEvidence: compactedEvidence.evidence }
                 : {}),
@@ -297,8 +296,16 @@ function projectPayloadContext(context, request) {
             ? { targetContentMessage: targetProjection.message }
             : {}),
         contextScope,
-        settledResultDiagnostics: settledResultProjection.diagnostics,
+        settledResultDiagnostics: projectSettledResultDiagnostics({
+            sourceResults: context.settledCapabilityResults,
+            includedResults: adapterEvidence.results,
+            deduplicatedReferenceDataCount: settledResultProjection.diagnostics.deduplicatedReferenceDataCount +
+                adapterEvidence.deduplicatedReferenceDataCount,
+            deduplicatedReferenceDataChars: settledResultProjection.diagnostics.deduplicatedReferenceDataChars +
+                adapterEvidence.deduplicatedReferenceDataChars,
+        }),
         reusedCompactedSourceCount: compactedEvidence.evidence?.sources.length ?? 0,
+        resultSourceOverrides: adapterEvidence.resultSourceOverrides,
     });
 }
 /**