@abot-ai/runtime 1.8.0 → 1.9.0

package/dist/src/runtime/orchestration/role-calls/skill-read.js

@@ -0,0 +1,196 @@
+import { Buffer } from "node:buffer";
+import { PERSONAL_SKILL_LIMITS } from "../../knowledge-skills/personal-contracts.js";
+import { isKnowledgeSkillId, KNOWLEDGE_SKILL_ID_MAX_LENGTH, KNOWLEDGE_SKILL_READ_MAX_ITEMS, } from "../../knowledge-skills/store.js";
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+/** Decode the exact Store snapshots supplied by the runtime read boundary. */
+export function decodeSkillReadCommand(input) {
+    const isRuntimeReadCommand = input.authority === "runtime" && input.type === "record_skill_read";
+    if (!isRuntimeReadCommand)
+        return { ok: false, code: "invalid_command" };
+    const hasCommandFields = exactKeys(input, [
+        "authority", "type", "callId", "invocationAttempt", "steeringVersion",
+        "operation", "selectors", "result",
+    ]);
+    if (!hasCommandFields)
+        return { ok: false, code: "invalid_command" };
+    if (!hasSkillReadBinding(input))
+        return { ok: false, code: "invalid_command" };
+    if (!hasSkillReadPayload(input))
+        return { ok: false, code: "invalid_command" };
+    return { ok: true, value: input };
+}
+/** Omission preserves heads and parked requests created before core Skill reads. */
+export function validateRoleSkillReads(state, policy) {
+    const reads = state.skillReads;
+    if (reads === undefined)
+        return [];
+    const invalid = [{ code: "invalid_role_skill_reads", path: "state.skillReads" }];
+    if (!Array.isArray(reads))
+        return invalid;
+    if (reads.length === 0)
+        return [];
+    const usesSupervisorContract = policy.authority.rootContractId === "supervisor";
+    if (!usesSupervisorContract)
+        return invalid;
+    const root = state.calls.find((call) => call.callId === state.rootCallId);
+    if (!root)
+        return invalid;
+    const isSupervisorRoot = root.parentCallId === null && root.roleId === "supervisor";
+    if (!isSupervisorRoot)
+        return invalid;
+    let previousAttempt = 0;
+    let previousSteeringVersion = 0;
+    for (const [index, read] of reads.entries()) {
+        if (!isRecord(read))
+            return invalid;
+        const hasReceiptFields = exactKeys(read, [
+            "readId", "callId", "invocationAttempt", "steeringVersion",
+            "operation", "selectors", "result",
+        ]);
+        if (!hasReceiptFields)
+            return invalid;
+        if (!hasSkillReadBinding(read))
+            return invalid;
+        if (!hasSkillReadPayload(read))
+            return invalid;
+        const hasSequentialIdentity = read.readId === `skill-read-${index + 1}`;
+        if (!hasSequentialIdentity)
+            return invalid;
+        const belongsToRoot = read.callId === root.callId;
+        if (!belongsToRoot)
+            return invalid;
+        const followsPreviousRead = read.invocationAttempt > previousAttempt;
+        if (!followsPreviousRead)
+            return invalid;
+        const precedesCurrentActivation = read.invocationAttempt < root.activationCount;
+        if (!precedesCurrentActivation)
+            return invalid;
+        const preservesSteeringOrder = read.steeringVersion >= previousSteeringVersion;
+        if (!preservesSteeringOrder)
+            return invalid;
+        previousAttempt = read.invocationAttempt;
+        previousSteeringVersion = read.steeringVersion;
+    }
+    return [];
+}
+function hasSkillReadBinding(value) {
+    if (!hasText(value.callId))
+        return false;
+    const hasInvocationAttempt = Number.isSafeInteger(value.invocationAttempt) &&
+        value.invocationAttempt >= 1;
+    if (!hasInvocationAttempt)
+        return false;
+    const hasSteeringVersion = Number.isSafeInteger(value.steeringVersion) &&
+        value.steeringVersion >= 0;
+    return hasSteeringVersion;
+}
+function hasSkillReadPayload(value) {
+    if (!Array.isArray(value.selectors))
+        return false;
+    if (!isRecord(value.result))
+        return false;
+    const selectors = value.selectors;
+    const isRead = value.operation === "read_skills";
+    const isList = value.operation === "list_skills";
+    if (!isRead && !isList)
+        return false;
+    if (isRead && !hasValidSelectors(selectors))
+        return false;
+    if (isList && selectors.length !== 0)
+        return false;
+    const result = value.result;
+    if (!Array.isArray(result.skills))
+        return false;
+    if (result.outcome === "failed") {
+        const hasFailureFields = exactKeys(result, ["outcome", "errorCode", "skills"]);
+        if (!hasFailureFields)
+            return false;
+        if (typeof result.errorCode !== "string")
+            return false;
+        const hasErrorCode = /^[a-z][a-z0-9_]*$/.test(result.errorCode);
+        if (!hasErrorCode)
+            return false;
+        return result.skills.length === 0;
+    }
+    if (result.outcome !== "completed")
+        return false;
+    if (!exactKeys(result, ["outcome", "skills"]))
+        return false;
+    const hasReadSize = result.skills.length > 0 &&
+        result.skills.length <= KNOWLEDGE_SKILL_READ_MAX_ITEMS;
+    if (isRead && !hasReadSize)
+        return false;
+    if (!result.skills.every((skill) => hasSkillSnapshot(skill, isRead)))
+        return false;
+    const skills = result.skills;
+    const hasUniqueSkills = new Set(skills.map(({ skillId }) => skillId)).size === skills.length;
+    if (!hasUniqueSkills)
+        return false;
+    if (!isRead)
+        return true;
+    const resolvesEverySelector = selectors.every((selector) => skills.some((skill) => matchesSelector(skill, selector)));
+    if (!resolvesEverySelector)
+        return false;
+    const containsOnlySelectedSkills = skills.every((skill) => selectors.some((selector) => matchesSelector(skill, selector)));
+    return containsOnlySelectedSkills;
+}
+function hasValidSelectors(values) {
+    const hasReadSize = values.length > 0 && values.length <= KNOWLEDGE_SKILL_READ_MAX_ITEMS;
+    if (!hasReadSize)
+        return false;
+    const maximumLength = Math.max(KNOWLEDGE_SKILL_ID_MAX_LENGTH, PERSONAL_SKILL_LIMITS.name);
+    const hasExactSelectors = values.every((value) => {
+        if (typeof value !== "string")
+            return false;
+        const hasBoundedLength = value.length > 0 && value.length <= maximumLength;
+        if (!hasBoundedLength)
+            return false;
+        return value.trim() === value;
+    });
+    if (!hasExactSelectors)
+        return false;
+    return new Set(values).size === values.length;
+}
+function matchesSelector(skill, selector) {
+    return skill.skillId === selector || skill.name === selector;
+}
+function hasSkillSnapshot(value, document) {
+    if (!isRecord(value))
+        return false;
+    const hasSnapshotFields = exactKeys(value, ["skillId", "name", "description", ...(document ? ["content"] : [])], ["source", ...(document ? ["revision"] : [])]);
+    if (!hasSnapshotFields)
+        return false;
+    if (!isKnowledgeSkillId(value.skillId))
+        return false;
+    if (!hasText(value.name))
+        return false;
+    if (!hasText(value.description))
+        return false;
+    const hasKnownSource = value.source === undefined || value.source === "system" || value.source === "personal";
+    if (!hasKnownSource)
+        return false;
+    if (value.revision !== undefined) {
+        const hasValidRevision = Number.isSafeInteger(value.revision) &&
+            value.revision >= 1 &&
+            value.revision <= PERSONAL_SKILL_LIMITS.revision;
+        if (!hasValidRevision)
+            return false;
+    }
+    if (document && !hasText(value.content))
+        return false;
+    if (value.source !== "personal")
+        return true;
+    if (value.name.length > PERSONAL_SKILL_LIMITS.name)
+        return false;
+    if (value.description.length > PERSONAL_SKILL_LIMITS.description)
+        return false;
+    if (!document)
+        return true;
+    if (value.revision === undefined)
+        return false;
+    const contentBytes = Buffer.byteLength(value.content, "utf8");
+    return contentBytes <= PERSONAL_SKILL_LIMITS.contentBytes;
+}
+function hasText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/src/runtime/orchestration/role-executors/activation/model-output-failure.d.ts

@@ -1,3 +1,3 @@
 import type { RoleExecutor, RoleExecutorActivationResult, RoleExecutorInput } from "../contracts.js";
-/** Contains recognized model-output failure or step timeout in the current call. */
+/** Contains recognized model failures and step timeouts in the current call. */
 export declare function executeRoleWithModelOutputFailure<TContext, TValue>(executor: RoleExecutor<TContext, TValue>, input: RoleExecutorInput<TContext>, maxSummaryLength: number, requestId: string): Promise<RoleExecutorActivationResult<TValue>>;

package/dist/src/runtime/orchestration/role-executors/activation/model-output-failure.js

@@ -1,8 +1,9 @@
 import { resolveModelOutputFailure, } from "../../../model/invalid-output-failure.js";
 import { ModelOutputIncompleteError } from "../../../model/provider-completion.js";
+import { ModelProviderFailure } from "../../../model/provider-failure.js";
 import { ModelStepTimeoutError } from "../../../steps/model-step-timeout.js";
 import { traceDebug } from "../../../observability/debug-logger.js";
-/** Contains recognized model-output failure or step timeout in the current call. */
+/** Contains recognized model failures and step timeouts in the current call. */
 export async function executeRoleWithModelOutputFailure(executor, input, maxSummaryLength, requestId) {
     try {
         return await executor.execute(input);
@@ -30,7 +31,8 @@ export async function executeRoleWithModelOutputFailure(executor, input, maxSumm
     }
 }
 function resolveChildModelOutputFailure(error) {
-    if (error instanceof ModelStepTimeoutError) {
+    if (error instanceof ModelProviderFailure ||
+        error instanceof ModelStepTimeoutError) {
         return Object.freeze({
             code: error.code,
             modelStep: error.modelStep,

package/dist/src/runtime/orchestration/worker-capabilities/binding/create-binding.js

@@ -5,6 +5,7 @@ import { workerCapabilityBindingRejection } from "./binding-rejection.js";
 import { BoundCapabilitySession } from "./bound-capability-session.js";
 import { copyBoundCapabilityCall, inspectInitialBindingAuthority, normalizeExecutionFreshness, } from "./call-authority.js";
 import { bindCapabilityDependencyResults } from "./dependency-results.js";
+import { projectSupervisorSkillCapabilityAdapters } from "../supervisor-skill-authority.js";
 export function createRoleCapabilityBinding(params) {
     const boundCall = copyBoundCapabilityCall(params.call);
     const emptyDiagnostic = createEmptyBindingDiagnostic(params.requestId, boundCall);
@@ -30,7 +31,9 @@ export function createRoleCapabilityBinding(params) {
         emptyDiagnostic,
     });
     const catalog = createBoundCapabilityCatalog({
-        adapters: params.adapters,
+        adapters: projectSupervisorSkillCapabilityAdapters({
+            head: initialHead, call: authority.authoritativeCall, adapters: params.adapters,
+        }),
         boundCall,
         emptyDiagnostic,
     });

package/dist/src/runtime/orchestration/worker-capabilities/contracts.d.ts

@@ -9,10 +9,10 @@ export declare const WORKER_CAPABILITY_INTENT_MAX_LENGTH = 500;
 /** Immutable Worker-only assignment for authoring one capability payload. */
 export declare const WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH = 8192;
 export declare const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
-export declare const WORKER_CAPABILITY_COUNT_MAX = 128;
+export declare const WORKER_CAPABILITY_COUNT_MAX = 130;
 export declare const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export declare const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH } from "../../../capabilities/normal-invocation/contracts.js";
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export declare const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;
@@ -165,6 +165,8 @@ export type WorkerCapabilityPreparedExecution = Readonly<{
     onAdmitted?(executionId: string): void;
     approvalRequest?: ToolApprovalRequest;
     applyApprovalDecision?(decision: BoundApprovalDecision): void;
+    /** Project a fenced rejection with adapter-owned lifecycle and evidence; never execute. */
+    rejectBeforeExecution?(executionId: string, code: string, message: string): WorkerCapabilityAdapterResult;
     execute(executionId: string): Promise<WorkerCapabilityAdapterResult>;
 }>;
 export type WorkerCapabilityAdapterPreparationInput<TContext> = Readonly<Omit<WorkerCapabilityAdapterExecutionInput<TContext>, "executionId"> & {

package/dist/src/runtime/orchestration/worker-capabilities/contracts.js

@@ -5,10 +5,10 @@ export const WORKER_CAPABILITY_INTENT_MAX_LENGTH = 500;
 /** Immutable Worker-only assignment for authoring one capability payload. */
 export const WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH = ROLE_CALL_OBJECTIVE_MAX_LENGTH;
 export const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
-export const WORKER_CAPABILITY_COUNT_MAX = 128;
+export const WORKER_CAPABILITY_COUNT_MAX = 130;
 export const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH } from "../../../capabilities/normal-invocation/contracts.js";
 export const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;

package/dist/src/runtime/orchestration/worker-capabilities/execution/approval-group.js

@@ -1,3 +1,5 @@
+import { projectSupervisorSkillCapabilityAdapters } from "../supervisor-skill-authority.js";
+import { fenceRestoredApprovalExecution } from "./execution-freshness.js";
 import { restorePreparationRejection } from "./preparation-rejection.js";
 import { isDeepStrictEqual } from "node:util";
 import { settleAdmittedPreparedGroup } from "./settle-prepared.js";
@@ -72,12 +74,13 @@ export async function restoreCapabilityApprovalGroup(params) {
     if (group.executionFreshnessToken !== undefined &&
         !isDeepStrictEqual(group.executionFreshnessToken, params.executionFreshness?.token))
         throw new Error("prepared_approval_freshness_mismatch");
+    const adapters = projectSupervisorSkillCapabilityAdapters({ head, call, adapters: params.adapters });
     const running = head.state.capabilityExecutions.filter((entry) => entry.status === "running");
     if (running.length !== group.entries.length)
         throw new Error("prepared_approval_group_mismatch");
     const invocations = await Promise.all(group.entries.map(async (entry) => {
         const admitted = running.find((value) => value.executionId === entry.executionId);
-        const adapter = params.adapters.find((value) => value.descriptor.capabilityId === entry.capabilityId);
+        const adapter = adapters.find((value) => value.descriptor.capabilityId === entry.capabilityId);
         if (!admitted ||
             admitted.callId !== group.callId ||
             admitted.invocationAttempt !== group.invocationAttempt ||
@@ -122,8 +125,8 @@ export async function restoreCapabilityApprovalGroup(params) {
         scopeMode: call.workerCapabilityScope ? "catalog_groups" : "full",
         scopeCatalogGroupIds: call.workerCapabilityScope?.catalogGroupIds ?? [],
         knownCatalogGroupCount: 0,
-        fullCapabilityCount: params.adapters.length,
-        filteredCapabilityCount: params.adapters.length,
+        fullCapabilityCount: adapters.length,
+        filteredCapabilityCount: adapters.length,
     };
     return Object.freeze({
         async execute(decisions) {
@@ -132,7 +135,10 @@ export async function restoreCapabilityApprovalGroup(params) {
                 ledger: params.ledger,
                 expectedHead: head,
                 call,
-                invocations,
+                invocations: invocations.map((invocation) => ({
+                    ...invocation,
+                    prepared: fenceRestoredApprovalExecution(invocation.prepared, params.executionFreshness),
+                })),
                 executionIds: group.entries.map((entry) => entry.executionId),
                 batch: group.batch,
                 diagnostic,

package/dist/src/runtime/orchestration/worker-capabilities/execution/execution-freshness.d.ts

@@ -0,0 +1,5 @@
+import type { WorkerCapabilityExecutionFreshness, WorkerCapabilityPreparedExecution } from "../contracts.js";
+export declare const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION: "steering_superseded_before_external_execution";
+export declare const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export declare function fenceRestoredApprovalExecution(prepared: WorkerCapabilityPreparedExecution, freshness: WorkerCapabilityExecutionFreshness | undefined): WorkerCapabilityPreparedExecution;

package/dist/src/runtime/orchestration/worker-capabilities/execution/execution-freshness.js

@@ -0,0 +1,31 @@
+export const STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION = "steering_superseded_before_external_execution";
+export const STEERING_SUPERSEDED_SUMMARY = "steering_superseded_before_external_execution: No external execution occurred because a newer active-request update superseded this capability invocation.";
+/** Preserve the admitted identity and decision binding; only fence its dispatch. */
+export function fenceRestoredApprovalExecution(prepared, freshness) {
+    if (!freshness)
+        return prepared;
+    return Object.freeze({
+        ...prepared,
+        async execute(executionId) {
+            if (freshness.isCurrent())
+                return prepared.execute(executionId);
+            if (prepared.rejectBeforeExecution)
+                return prepared.rejectBeforeExecution(executionId, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY);
+            return Object.freeze({
+                outcome: "failed",
+                observedEffect: "none",
+                summary: STEERING_SUPERSEDED_SUMMARY,
+                // This is request control, not evidence of a repeatable tool failure.
+                failureOutcomeFingerprint: null,
+                exactResult: Object.freeze({
+                    kind: "runtime_capability_rejection_v1",
+                    authority: "runtime",
+                    status: "rejected",
+                    stage: "before_external_execution",
+                    code: STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION,
+                    message: STEERING_SUPERSEDED_SUMMARY,
+                }),
+            });
+        },
+    });
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.d.ts

@@ -1,3 +1,5 @@
 import type { WorkerCapabilityPayloadAuthor, WorkerCapabilityPayloadModelRequest } from "./payload-contracts.js";
 /** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
 export declare function projectWorkerPayloadCompactionInput(input: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0], requestId: string): Pick<WorkerCapabilityPayloadModelRequest, "superWorkerCompaction">;
+/** Root payload checkpoints are isolated to the exact preparation and stage. */
+export declare function rootPayloadCompactionScopeId(input: WorkerCapabilityPayloadModelRequest): string;

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.js

@@ -1,8 +1,6 @@
 import { assertSuperWorkerCompactionSidecarBinding, readSuperWorkerCompactionSidecar, } from "../../context/super-worker-compaction-sidecar.js";
 /** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
 export function projectWorkerPayloadCompactionInput(input, requestId) {
-    if (input.call.roleId !== "worker")
-        return {};
     const sidecar = readSuperWorkerCompactionSidecar(input.settledCapabilityResults);
     if (!sidecar)
         return {};
@@ -12,3 +10,10 @@ export function projectWorkerPayloadCompactionInput(input, requestId) {
     });
     return { superWorkerCompaction: sidecar };
 }
+/** Root payload checkpoints are isolated to the exact preparation and stage. */
+export function rootPayloadCompactionScopeId(input) {
+    if (!("root" in input.context))
+        throw new Error("payload_root_context_required");
+    return ["payload", input.context.root.callId, input.executionId,
+        input.context.payloadStage?.index ?? 0].join(":");
+}

package/dist/src/runtime/orchestration/worker-capabilities/supervisor-skill-authority.d.ts

@@ -0,0 +1,19 @@
+import type { ToolAvailabilityEntry } from "../../../capabilities/tool-types.js";
+import type { ExecutionPolicyAuthoritySnapshot, RoleCallFrame, RoleCallLedgerHead } from "../role-calls/index.js";
+import type { WorkerCapabilityAdapter, WorkerCapabilityDescriptor } from "./contracts.js";
+export declare function isSupervisorSkillWriteCapabilityId(capabilityId: string): boolean;
+export declare function projectSupervisorWorkerCapabilityDescriptors(params: {
+    authority: ExecutionPolicyAuthoritySnapshot;
+    descriptors: readonly WorkerCapabilityDescriptor[];
+}): readonly WorkerCapabilityDescriptor[];
+/** Descriptions and selectable descriptors obey the same write ownership. */
+export declare function projectSupervisorWorkerCapabilityBriefEntries(params: {
+    authority: ExecutionPolicyAuthoritySnapshot;
+    entries: readonly ToolAvailabilityEntry[] | undefined;
+}): readonly ToolAvailabilityEntry[] | undefined;
+/** The same boundary applies before execution and before approval restoration. */
+export declare function projectSupervisorSkillCapabilityAdapters<TContext>(params: {
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    adapters: readonly WorkerCapabilityAdapter<TContext>[];
+}): readonly WorkerCapabilityAdapter<TContext>[];

package/dist/src/runtime/orchestration/worker-capabilities/supervisor-skill-authority.js

@@ -0,0 +1,43 @@
+import { knowledgeSkillWriteOperations } from "../../capabilities/knowledge-skills/write-contract.js";
+import { hasSuperContextContract } from "../../context/super-context-policy.js";
+const skillAuthoringCapabilityIds = new Set(knowledgeSkillWriteOperations.map(({ operationId }) => operationId));
+export function isSupervisorSkillWriteCapabilityId(capabilityId) {
+    return skillAuthoringCapabilityIds.has(capabilityId);
+}
+export function projectSupervisorWorkerCapabilityDescriptors(params) {
+    if (!hasSuperContextContract(params.authority, "supervisor"))
+        return params.descriptors;
+    return Object.freeze(params.descriptors.filter((descriptor) => !isSupervisorSkillWriteCapabilityId(descriptor.capabilityId)));
+}
+/** Descriptions and selectable descriptors obey the same write ownership. */
+export function projectSupervisorWorkerCapabilityBriefEntries(params) {
+    if (!hasSuperContextContract(params.authority, "supervisor"))
+        return params.entries;
+    if (params.entries === undefined)
+        return undefined;
+    return Object.freeze(params.entries.filter(({ operationId }) => !isSupervisorSkillWriteCapabilityId(operationId)));
+}
+/** The same boundary applies before execution and before approval restoration. */
+export function projectSupervisorSkillCapabilityAdapters(params) {
+    if (!hasSuperContextContract(params.head.policy.authority, "supervisor"))
+        return params.adapters;
+    // Preserve malformed entries for the existing adapter validation boundary.
+    if (!Array.isArray(params.adapters))
+        return params.adapters;
+    if (isSupervisorRootCapabilityCall(params.head, params.call)) {
+        return Object.freeze(params.adapters.filter((adapter) => hasMalformedCapabilityIdentity(adapter) ||
+            isSupervisorSkillWriteCapabilityId(adapter.descriptor.capabilityId)));
+    }
+    if (params.call.roleId !== "worker")
+        return params.adapters;
+    return Object.freeze(params.adapters.filter((adapter) => hasMalformedCapabilityIdentity(adapter) ||
+        !isSupervisorSkillWriteCapabilityId(adapter.descriptor.capabilityId)));
+}
+function isSupervisorRootCapabilityCall(head, call) {
+    if (call.callId !== head.state.rootCallId)
+        return false;
+    return call.parentCallId === null;
+}
+function hasMalformedCapabilityIdentity(adapter) {
+    return typeof adapter?.descriptor?.capabilityId !== "string";
+}

package/dist/src/runtime/plugins/loader.js

@@ -1,3 +1,4 @@
+import { hasCoreToolContractCollision } from "../capabilities/core-tool-contracts.js";
 import { pluginLoadConfiguration } from "./configuration-context.js";
 import { readPluginConfigurationStore, } from "./configuration-store.js";
 import { validateManifestEntrypoint } from "./entrypoint-validation.js";
@@ -117,8 +118,8 @@ export function loadConfiguredRuntimePlugins(config) {
             ...selection.disabledPluginIds,
         ]),
     });
-    const compatiblePlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
-    const allPluginsIncompatible = discoveredPlugins.length > 0 && compatiblePlugins.length === 0;
+    const compatiblePlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported).filter(({ manifest }) => !hasCoreToolContractCollision(manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities));
+    const allPluginsUnavailable = discoveredPlugins.length > 0 && compatiblePlugins.length === 0;
     const selectedPlugins = compatiblePlugins
         .map((plugin) => ({
         plugin,
@@ -131,7 +132,7 @@ export function loadConfiguredRuntimePlugins(config) {
         .filter(({ selectedCapabilityIds }) => selectedCapabilityIds.length > 0);
     const host = {
         rootDir: config.paths.rootDir,
-        pluginConfiguration: allPluginsIncompatible
+        pluginConfiguration: allPluginsUnavailable
             ? {}
             : readPluginConfigurationStore(config.paths.rootDir).plugins,
         runtimeId: config.runtimeId,
@@ -181,11 +182,11 @@ export function loadBundledRuntimePlugins() {
         return cached;
     }
     const discoveredPlugins = discoverAgentPluginManifests(packageRoot);
-    const selectedPlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
-    const allPluginsIncompatible = discoveredPlugins.length > 0 && selectedPlugins.length === 0;
+    const selectedPlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported).filter(({ manifest }) => !hasCoreToolContractCollision(manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities));
+    const allPluginsUnavailable = discoveredPlugins.length > 0 && selectedPlugins.length === 0;
     const host = {
         rootDir,
-        pluginConfiguration: allPluginsIncompatible
+        pluginConfiguration: allPluginsUnavailable
             ? {}
             : readPluginConfigurationStore(rootDir).plugins,
         runtimeId: "default",

package/dist/src/runtime/plugins/manifest-projection.js

@@ -41,6 +41,9 @@ export function projectManifestRuntimeContract(discovered, selectedCapabilityIds
             definition: {
                 name: capabilityId,
                 pluginName: manifest.name,
+                ...(manifest.description !== undefined
+                    ? { pluginDescription: manifest.description }
+                    : {}),
                 ...(capability.requiredPermissionMode
                     ? { requiredPermissionMode: capability.requiredPermissionMode }
                     : {}),

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

@@ -49,6 +49,7 @@ export async function validateApprovalResume(services, snapshot, current) {
             sessionStore: services.sessions,
             attachmentStore: services.attachments,
             toolRegistry: services.tools,
+            knowledgeSkillStore: services.knowledgeSkillStore,
             modelGatewayClient: models,
             eventSinkFactory: { create: () => events },
             sessionMemoryCompactor: services.sessionMemoryCompactor,

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

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

package/dist/src/runtime/request/capability-execution-freshness.js

@@ -22,7 +22,12 @@ export function restoreApprovalExecutionFreshness(token, requestSteering) {
     });
     if (!isDeepStrictEqual(current.token, token))
         throw new Error("request_approval_steering_mismatch");
-    if (!current.isCurrent())
+    // A newer accepted prefix invalidates execution, not the saved approval.
+    // A closed inbox has no current version and must remain terminal.
+    if (!hasLiveSteeringInbox(inbox))
         throw new Error("request_approval_steering_superseded");
     return Object.freeze({ token, isCurrent: current.isCurrent });
 }
+function hasLiveSteeringInbox(inbox) {
+    return inbox.isCurrent(inbox.snapshot().version);
+}

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

@@ -1,3 +1,4 @@
+import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
 import type { RequestToolResources } from "../capabilities/request-tool-resources.js";
 import type { CapabilityApprovalGate } from "../orchestration/worker-capabilities/approval-contracts.js";
 import type { RequestApprovalExecution } from "./approval-wait/snapshot.js";
@@ -44,6 +45,7 @@ export type RequestHandlerOptions = {
     sessionStore?: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
     toolRegistry?: ToolRegistry;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     toolApprovalController?: ToolApprovalController;
     requestSteering?: RequestSteeringInbox;
     /** Trusted automation-only receipt boundary; never accepted from client JSON. */

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

@@ -37,6 +37,8 @@ export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
         });
     },
     async authorResponse(request, options) {
+        if (options.directResponse !== undefined)
+            return options.directResponse;
         const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
         return runExecutionAgentAuthoredResponse(request, {
             head: options.head,
@@ -115,7 +117,15 @@ function projectKernelDecision(decision, steeringVersion) {
                 ...presentation,
             });
         case "respond":
-            return Object.freeze({ action: "respond", ...presentation });
+            return Object.freeze({
+                action: "respond", ...presentation,
+                ...(decision.response !== undefined ? {
+                    directResponse: Object.freeze({
+                        finalResponse: decision.response,
+                        memoryCandidates: decision.memoryCandidates ?? Object.freeze([]),
+                    }),
+                } : {}),
+            });
         case "blocked":
             return Object.freeze({
                 action: "blocked",

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

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

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

@@ -1,3 +1,4 @@
+import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
 import type { SuperFailureFinalization } from "./super-failure-explanation.js";
 import type { RequestModelStepPort } from "../model/model-step-port.js";
 import { type RequestExecutionSeed, type RequestModelInvocationView } from "./contracts.js";
@@ -12,5 +13,6 @@ export declare function createScopeSurface(input: Readonly<{
     modelInvocation: RequestModelInvocationView;
     modelSteps: RequestModelStepPort;
     capabilities: RequestWorkerCapabilities;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     superFailureFinalization?: SuperFailureFinalization | undefined;
 }>): RequestExecutionScope;

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

@@ -34,7 +34,13 @@ export function createCapabilityCompositionView(facets, modelSteps) {
         modelSteps: enumerableGetter(() => modelSteps),
         sessionId: enumerableGetter(() => facets.identity.sessionId),
         prompt: enumerableGetter(() => facets.input.prompt),
+        ...(facets.input.attachments !== undefined
+            ? { attachments: enumerableGetter(() => facets.input.attachments) }
+            : {}),
         historyMessages: enumerableGetter(() => facets.session.historyMessages),
+        ...(facets.session.sessionMemory !== undefined
+            ? { sessionMemory: enumerableGetter(() => facets.session.sessionMemory) }
+            : {}),
         toolPermissionMode: enumerableGetter(() => facets.lifecycle.toolPermissionMode),
         ...(facets.lifecycle.toolApprovalController !== undefined
             ? {
@@ -107,6 +113,7 @@ export function createScopeSurface(input) {
         policy: hiddenValue(policy),
         modelInvocation: hiddenValue(modelInvocation),
         capabilities: hiddenValue(capabilities),
+        ...(input.knowledgeSkillStore ? { knowledgeSkillStore: hiddenValue(input.knowledgeSkillStore) } : {}),
         ...(input.superFailureFinalization
             ? {
                 superFailureFinalization: hiddenValue(input.superFailureFinalization),