@abot-ai/runtime 1.8.0 → 1.9.0

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

@@ -0,0 +1,48 @@
+import { projectStoredCompletedRoleChild } from "../orchestration/role-calls/child-return.js";
+import { performRootMemoryRecall } from "./root-memory-recall.js";
+import { performRootSkillRead } from "./root-skill-read.js";
+export function isRootReferenceDecision(decision) {
+    return ["recall_memory", "list_skills", "read_skills"].includes(decision.action);
+}
+/** Core reference actions use the same root loop without opening a child. */
+export async function performRootReferenceAction(request, ledger, activation, resume) {
+    const params = {
+        request,
+        ledger,
+        ...activation,
+        steeringVersion: activation.decisionSteeringVersion,
+        resume,
+    };
+    if (params.decision.action === "recall_memory") {
+        await performRootMemoryRecall({ ...params, query: params.decision.query });
+        return params.resume;
+    }
+    await performRootSkillRead({ ...params, decision: params.decision });
+    return projectResumeAfterSkillRead(params.ledger.current(), params.resume);
+}
+/** A reference read advances the root activation without changing its completed children. */
+function projectResumeAfterSkillRead(head, resume) {
+    if (!resume)
+        return undefined;
+    const call = head.state.calls.find(({ callId }) => callId === resume.callerCallId);
+    if (!call ||
+        call.callId !== head.state.rootCallId ||
+        call.status !== "active")
+        throw new Error("skill_read_resume_caller_invalid");
+    const completedChildren = call.childCallIds.flatMap((childCallId) => {
+        const child = head.state.calls.find(({ callId }) => callId === childCallId);
+        if (child?.status !== "completed")
+            return [];
+        return [
+            projectStoredCompletedRoleChild(head.state, { callerCallId: call.callId, childCallId }, head.policy),
+        ];
+    });
+    if (!completedChildren.some((child) => child.childCallId === resume.returnedChildCallId &&
+        child.resultRef === resume.returnedResultRef))
+        throw new Error("skill_read_resume_result_invalid");
+    return Object.freeze({
+        ...resume,
+        invocationAttempt: call.activationCount,
+        completedChildren: Object.freeze(completedChildren),
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { SkillReadDecision } from "../steps/skill-read-decision.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+/** Read synchronously, then commit the exact snapshot and the next root activation together. */
+export declare function performRootSkillRead(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    steeringVersion: number;
+    decision: SkillReadDecision;
+}): Promise<void>;
+export declare function canRootReadSkills(request: RequestExecutionScope, head: RoleCallLedgerHead, call: RoleCallFrame): boolean;

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

@@ -0,0 +1,102 @@
+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";
+/** Read synchronously, then commit the exact snapshot and the next root activation together. */
+export async function performRootSkillRead(params) {
+    const { request, head, call } = params;
+    request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    if (!steering.isCurrent(params.steeringVersion))
+        return;
+    if (!hasSuperContextContract(head.policy.authority, "supervisor"))
+        throw new Error("skill_read_policy_invalid");
+    if (!request.knowledgeSkillStore)
+        throw new Error("skill_read_unavailable");
+    const identity = {
+        authority: "runtime",
+        type: "record_skill_read",
+        callId: call.callId,
+        invocationAttempt: call.activationCount,
+        steeringVersion: params.steeringVersion,
+    };
+    const reservation = {
+        ...identity,
+        ...failedRead(params.decision, "knowledge_skill_unavailable"),
+    };
+    const exhausted = findRoleActivationReservationIssue(head.state, head.policy, reservation);
+    if (exhausted)
+        throw new Error(`role_call_ledger_rejected:${exhausted.code}`);
+    const payload = readStore(request.knowledgeSkillStore, params.decision);
+    request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(params.steeringVersion))
+        return;
+    const committed = await params.ledger.apply({
+        expectedHead: head,
+        command: { ...identity, ...payload },
+    });
+    if (!committed.ok)
+        throw new Error(`role_call_ledger_rejected:${committed.code}`);
+    emitRuntimeStatus(request, {
+        stage: "supervisor",
+        phase: "skills",
+        message: readStatus(payload),
+    });
+}
+function readStore(store, decision) {
+    try {
+        if (decision.action === "list_skills")
+            return {
+                operation: "list_skills",
+                selectors: [],
+                result: {
+                    outcome: "completed",
+                    skills: store.list().map((skill) => ({ ...skill })),
+                },
+            };
+        const resolved = resolveKnowledgeSkillReadTargets(store, decision.skillIds);
+        if (!resolved.ok)
+            return failedRead(decision, resolved.errorCode);
+        return {
+            operation: "read_skills",
+            selectors: [...decision.skillIds],
+            result: {
+                outcome: "completed",
+                skills: resolved.skills.map((skill) => ({ ...skill })),
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof KnowledgeSkillError)
+            return failedRead(decision, error.code);
+        throw error;
+    }
+}
+function failedRead(decision, errorCode) {
+    const result = { outcome: "failed", errorCode, skills: [] };
+    if (decision.action === "list_skills")
+        return { operation: "list_skills", selectors: [], result };
+    return {
+        operation: "read_skills",
+        selectors: [...decision.skillIds],
+        result,
+    };
+}
+function readStatus(payload) {
+    if (payload.result.outcome === "failed")
+        return `Skill lookup failed: ${payload.result.errorCode}`;
+    if (payload.operation === "list_skills")
+        return `Listed ${payload.result.skills.length} Skills`;
+    return `Read Skills: ${payload.result.skills.map(({ name }) => name).join(", ")}`;
+}
+export function canRootReadSkills(request, head, call) {
+    if (!request.knowledgeSkillStore)
+        return false;
+    if (!hasSuperContextContract(head.policy.authority, "supervisor"))
+        return false;
+    return (call.activationCount <
+        resolveRoleActivationBudget(head.state, head.policy)
+            .maximumAcceptedActivationsPerCall);
+}

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

@@ -1,12 +1,15 @@
+import { prepareInitialMemory } from "../long-term-memory/initial-context.js";
 import { createRequestRoleCallPolicy } from "./role-call-policy.js";
 import { restoreApprovalExecutionFreshness } from "./capability-execution-freshness.js";
 import { captureRoleCallLedgerCheckpoint } from "../orchestration/role-calls/checkpoint.js";
 import { isRoleApprovalWait } from "../orchestration/role-executors/approval-continuation.js";
-import { resumeCapabilityApprovalGroup } from "../orchestration/worker-capabilities/execution/approval-group.js";
+import { restoreCapabilityApprovalGroup } from "../orchestration/worker-capabilities/execution/approval-group.js";
 import { createRoleApprovalContinuation, validateRequestApprovalContinuation, } from "./approval-continuation.js";
 import { createRoleCallLedger, resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { attachRequestPlannerRoleCallEvents } from "./role-call-planner-events.js";
+import { attachRequestRoleDelegationEvents } from "./role-call-delegation-events.js";
+import { attachRequestRoleReturnEvents } from "./role-call-return-events.js";
 import { runRootExecutionKernel } from "./root-execution-kernel.js";
 import { persistSettledSessionArtifactPaths, } from "./session-artifact-path-persistence.js";
 export async function runRequestRunner(request, options = {}) {
@@ -26,8 +29,10 @@ export async function runRequestRunner(request, options = {}) {
             }
             : {}),
     });
+    const initialMemory = await prepareInitialMemory(request, options.continuation?.ledger.state.initialMemory);
     const ledger = createRoleCallLedger({
         requestId: request.requestId,
+        ...(initialMemory !== undefined ? { initialMemory } : {}),
         ...(options.continuation
             ? { checkpoint: options.continuation.ledger }
             : {}),
@@ -37,20 +42,31 @@ export async function runRequestRunner(request, options = {}) {
         ledger,
         onEvent: request.onEvent,
     });
+    attachRequestRoleDelegationEvents({
+        ledger,
+        onEvent: request.onEvent,
+    });
+    attachRequestRoleReturnEvents({
+        ledger,
+        onEvent: request.onEvent,
+    });
     let result;
     try {
         let continuation;
         if (options.continuation) {
             validateRequestApprovalContinuation(options.continuation, ledger, request.workerCapabilities.provider.getDescriptors());
+            request.abortSignal.throwIfAborted();
             const executionFreshness = restoreApprovalExecutionFreshness(options.continuation.preparedGroup.executionFreshnessToken, request.requestSteering);
-            const settled = await resumeCapabilityApprovalGroup({
+            const prepared = await restoreCapabilityApprovalGroup({
                 ...(executionFreshness ? { executionFreshness } : {}),
                 ledger,
                 context: request.workerCapabilities.executionContext,
                 adapters: request.workerCapabilities.provider.getAdapters(),
                 group: options.continuation.preparedGroup,
-                decisions: options.decisions ?? [],
             });
+            request.abortSignal.throwIfAborted();
+            restoreApprovalExecutionFreshness(options.continuation.preparedGroup.executionFreshnessToken, request.requestSteering);
+            const settled = await prepared.execute(options.decisions ?? []);
             continuation = createRoleApprovalContinuation(options.continuation, settled.executionIds);
         }
         else {

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,25 +13,64 @@ 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 }
+                : {}),
             ...(options.memoryRecallMessage
                 ? { memoryRecallMessage: options.memoryRecallMessage }
                 : {}),
             ...(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 }
+                : {}),
             ...(options.memoryRecallMessage
                 ? { memoryRecallMessage: options.memoryRecallMessage }
                 : {}),
@@ -36,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-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,4 @@
+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";
@@ -68,8 +69,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()),
     });
 }