@abot-ai/runtime 1.8.1 → 2.0.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/ports.d.ts

@@ -4,7 +4,7 @@ import type { AgentMode, ModelReasoningLevel, ModelStep } from "../shared/types.
 import type { ContextBuckets, ModelContextMessage } from "../sessions/context-window.js";
 import type { SessionArtifactPathInput, SessionContextEntryKind, SessionDeleteResult, SessionListResult, SessionMessageDeleteResult, SessionMessageGrounding, SessionMessageObservationMeta, SessionMessageRole, SessionMessageSource, SessionMessageTaskType, SessionMessagesClearResult, SessionRecord, SessionRequestReplay, SessionSnapshot, SessionThinkingTraceEntry } from "../sessions/types.js";
 import type { SessionMemoryRepository } from "../sessions/memory/contracts.js";
-import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult, ModelGatewayPolicyConfig, ModelPreference, ModelTokenUsage } from "../model-gateway/types.js";
+import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult, ModelGatewayPolicyConfig, ModelPreference, ModelReasoningPreference, ModelTokenUsage } from "../model-gateway/types.js";
 import type { RuntimeAttachmentStore } from "./attachments/store.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
 import type { StreamCallbacks } from "../model-gateway/client-stream-parser.js";
@@ -220,6 +220,7 @@ export type ModelGatewayInvokeParams = StreamCallbacks & {
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     abortSignal: AbortSignal;
     debugRequestId?: string;
@@ -233,6 +234,7 @@ export type ModelGatewayRawInvokeParams = {
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     abortSignal: AbortSignal;
     debugRequestId?: string;

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

@@ -2,6 +2,10 @@ import type { SessionProject } from "../../sessions/project-binding.js";
 export type RuntimeProject = SessionProject & Readonly<{
     createdAt: string;
 }>;
+export type RuntimeProjectCatalog = Readonly<{
+    projects: readonly RuntimeProject[];
+    deletedProjectIds: readonly string[];
+}>;
 export type ProjectFolder = Readonly<{
     name: string;
     path: string;
@@ -19,6 +23,8 @@ export type ProjectFolderPage = Readonly<{
 }>;
 export type RuntimeProjectService = Readonly<{
     list: () => Promise<readonly RuntimeProject[]>;
+    catalog: () => Promise<RuntimeProjectCatalog>;
+    delete: (projectId: string) => Promise<void>;
     get: (id: string) => Promise<RuntimeProject | null>;
     create: (input: {
         name?: string;

package/dist/src/runtime/projects/registry-format.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeProjectCatalog } from "./contracts.js";
+/** Legacy arrays have no removals; versioned catalogs retain explicit deletions. */
+export declare function readProjectCatalog(input: unknown): RuntimeProjectCatalog;

package/dist/src/runtime/projects/registry-format.js

@@ -0,0 +1,50 @@
+import { copySessionProject } from "../../sessions/project-binding.js";
+function isCatalogRecord(value) {
+    if (!value)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    return typeof value === "object";
+}
+function hasCatalogFields(value) {
+    return Object.keys(value).every((key) => ["version", "projects", "deletedProjectIds"].includes(key));
+}
+function hasDeletedProjectIds(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (!value.every((id) => typeof id === "string" && id.trim().length > 0))
+        return false;
+    return new Set(value).size === value.length;
+}
+function readProjects(input) {
+    const projects = input.map((entry) => {
+        const record = entry;
+        const project = copySessionProject(record);
+        if (typeof record.createdAt !== "string")
+            throw new Error("project_registry_created_at_invalid");
+        return { ...project, createdAt: record.createdAt };
+    });
+    if (new Set(projects.map((project) => project.id)).size !== projects.length)
+        throw new Error("project_registry_duplicate_id");
+    return projects;
+}
+/** Legacy arrays have no removals; versioned catalogs retain explicit deletions. */
+export function readProjectCatalog(input) {
+    if (Array.isArray(input))
+        return { projects: readProjects(input), deletedProjectIds: [] };
+    if (!isCatalogRecord(input))
+        throw new Error("project_registry_invalid");
+    if (input.version !== 1)
+        throw new Error("project_registry_version_invalid");
+    if (!hasCatalogFields(input))
+        throw new Error("project_registry_fields_invalid");
+    if (!Array.isArray(input.projects))
+        throw new Error("project_registry_projects_invalid");
+    if (!hasDeletedProjectIds(input.deletedProjectIds))
+        throw new Error("project_registry_deleted_ids_invalid");
+    const projects = readProjects(input.projects);
+    const deleted = new Set(input.deletedProjectIds);
+    if (projects.some((project) => deleted.has(project.id)))
+        throw new Error("project_registry_active_deleted_conflict");
+    return { projects, deletedProjectIds: [...input.deletedProjectIds] };
+}

package/dist/src/runtime/projects/repository.d.ts

@@ -1,10 +1,13 @@
-import type { RuntimeProject } from "./contracts.js";
-/** One environment owner serializes updates; rename publishes a complete registry. */
+import type { RuntimeProject, RuntimeProjectCatalog } from "./contracts.js";
+/** One environment owner serializes updates; rename publishes a complete catalog. */
 export declare class FileProjectRepository {
     private readonly filename;
     private tail;
     constructor(filename: string);
-    list(): Promise<RuntimeProject[]>;
+    catalog(): Promise<RuntimeProjectCatalog>;
+    list(): Promise<readonly RuntimeProject[]>;
     create(project: RuntimeProject): Promise<RuntimeProject>;
+    delete(projectId: string): Promise<void>;
+    private mutate;
     private save;
 }