@abot-ai/runtime 1.8.1 → 1.9.0

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

@@ -8,6 +8,8 @@ import { createRoleApprovalContinuation, validateRequestApprovalContinuation, }
 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 = {}) {
@@ -40,6 +42,14 @@ 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;

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-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()),
     });
 }

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 {};