@abot-ai/runtime 1.8.1 → 1.9.0

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

@@ -0,0 +1,47 @@
+import { type KnowledgeSkillDocument, type KnowledgeSkillMetadata } from "../../knowledge-skills/store.js";
+import type { RoleCallPolicy, RoleCallState, RoleCallValidationIssue } from "./contracts.js";
+export type RoleSkillReadResult<T> = Readonly<{
+    outcome: "completed";
+    skills: readonly T[];
+}> | Readonly<{
+    outcome: "failed";
+    errorCode: string;
+    skills: readonly [];
+}>;
+export type RoleSkillReadPayload = Readonly<{
+    operation: "list_skills";
+    selectors: readonly [];
+    result: RoleSkillReadResult<KnowledgeSkillMetadata>;
+}> | Readonly<{
+    operation: "read_skills";
+    selectors: readonly string[];
+    result: RoleSkillReadResult<KnowledgeSkillDocument>;
+}>;
+type RoleSkillReadBinding = Readonly<{
+    callId: string;
+    invocationAttempt: number;
+    steeringVersion: number;
+}>;
+export type RoleSkillRead = RoleSkillReadBinding & RoleSkillReadPayload & Readonly<{
+    readId: string;
+}>;
+export type RecordRoleSkillReadCommand = RoleSkillReadBinding & RoleSkillReadPayload & Readonly<{
+    authority: "runtime";
+    type: "record_skill_read";
+}>;
+export type RoleSkillReadCommitEffect = RoleSkillReadBinding & Readonly<{
+    type: "skill_read_recorded";
+    readId: string;
+    operation: RoleSkillReadPayload["operation"];
+}>;
+/** Decode the exact Store snapshots supplied by the runtime read boundary. */
+export declare function decodeSkillReadCommand(input: Record<string, unknown>): Readonly<{
+    ok: true;
+    value: RecordRoleSkillReadCommand;
+}> | Readonly<{
+    ok: false;
+    code: "invalid_command";
+}>;
+/** Omission preserves heads and parked requests created before core Skill reads. */
+export declare function validateRoleSkillReads(state: RoleCallState, policy: RoleCallPolicy): readonly RoleCallValidationIssue[];
+export {};

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,7 +9,7 @@ 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";

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

@@ -5,7 +5,7 @@ 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";

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

@@ -1,3 +1,4 @@
+import { projectSupervisorSkillCapabilityAdapters } from "../supervisor-skill-authority.js";
 import { fenceRestoredApprovalExecution } from "./execution-freshness.js";
 import { restorePreparationRejection } from "./preparation-rejection.js";
 import { isDeepStrictEqual } from "node:util";
@@ -73,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 ||
@@ -123,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) {

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/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/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-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),

package/dist/src/runtime/request/execution-scope.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 RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import { type SuperFailureFinalization } from "./super-failure-explanation.js";
 import type { ToolAvailabilitySource } from "../capabilities/tool-availability.js";
@@ -5,7 +7,7 @@ import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-ca
 import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
 /** Request fields required while the request-bound capability catalog is built. */
-export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
+export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "sessionMemory" | "attachments" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
 /**
  * Stable request-owned context delivered to capability adapters.
  * Passive session artifact paths and request containers are excluded.
@@ -13,7 +15,7 @@ export type RequestCapabilityCompositionView = BoundRequestModelInvocationContex
 export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory" | "memoryRecallLimit" | "scheduledExecution">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
     filesystemScope?: RuntimeFilesystemScope;
-    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
+    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource & AvailableSkillsSource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
 export type RequestExecutionPolicyFacet = Readonly<{
@@ -35,12 +37,14 @@ export type RequestExecutionScope = RequestExecutionSeed & BoundRequestModelInvo
     capabilities: RequestWorkerCapabilities;
     superFailureFinalization?: SuperFailureFinalization;
     workerCapabilities: RequestWorkerCapabilities;
+    knowledgeSkillStore?: KnowledgeSkillStore;
 }>;
 export type CompiledRequestExecutionPolicy = RequestExecutionScope["executionPolicy"];
 export type RequestWorkerCapabilityProviderSource = Pick<RequestExecutionScope, "workerCapabilities">;
 export type RequestWorkerCapabilityCatalog = Pick<WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>, "getDescriptors" | "getExecutionGuidance">;
 export declare function createRequestExecutionScope(input: Readonly<{
     seed: RequestExecutionSeed;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     requestWorkingDirectory?: string;
     executionPolicy: CompiledRequestExecutionPolicy;
     superFailureFinalization?: SuperFailureFinalization;

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

@@ -1,3 +1,6 @@
+import { matchesToolSelectionId } from "../../shared/tool-selection.js";
+import { CORE_TOOL_CONTRACTS } from "../capabilities/core-tool-contracts.js";
+import { captureModelPluginConfig } from "../config/model-plugin-config.js";
 import { captureRuntimeFilesystemScope, } from "../context/runtime-filesystem-scope.js";
 import { createSuperFailureFinalization, } from "./super-failure-explanation.js";
 import { RequestModelStepInvoker } from "../model/invoke-step.js";
@@ -22,6 +25,9 @@ export function createRequestExecutionScope(input) {
         modelInvocation,
         modelSteps,
         capabilities,
+        ...(input.knowledgeSkillStore && !isSkillStoreDeniedForModel(input.seed)
+            ? { knowledgeSkillStore: input.knowledgeSkillStore }
+            : {}),
         superFailureFinalization: input.superFailureFinalization ??
             createSuperFailureFinalization({
                 request: input.seed,
@@ -44,3 +50,8 @@ function createRequestExecutionPolicyFacet(selection, executionPolicy) {
         executionPolicy,
     });
 }
+/** Direct core reads retain the same captured model restriction as abot_skills. */
+function isSkillStoreDeniedForModel(seed) {
+    const deniedSelectors = captureModelPluginConfig(seed.executionPolicySelection?.plugins)?.deny ?? [];
+    return deniedSelectors.some((selector) => matchesToolSelectionId("", CORE_TOOL_CONTRACTS.skills.name, selector));
+}

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

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