@abot-ai/runtime 1.7.0 → 1.8.0

package/dist/src/runtime/adapters/long-term-memory/file-lock/owner-record.js

@@ -3,10 +3,12 @@ import { open } from "node:fs/promises";
 import { join } from "node:path";
 import { directorySnapshot, fileSystemErrorCode, LEASE_DIRECTORY_NAME, MAX_LOCK_RECORD_BYTES, } from "./contracts.js";
 import { isLockOwnerIdentity } from "./owner-identity.js";
+import { observeLockReadFailure } from "./path-observation.js";
 export async function readOwnerRecord(lockPath, entryName, expectedToken, directoryModifiedAtMs) {
     let handle;
     try {
-        handle = await open(join(lockPath, LEASE_DIRECTORY_NAME, entryName), constants.O_RDONLY | constants.O_NOFOLLOW);
+        const ownerPath = join(lockPath, LEASE_DIRECTORY_NAME, entryName);
+        handle = await open(ownerPath, constants.O_RDONLY | constants.O_NOFOLLOW).catch(async (error) => { throw await observeLockReadFailure(ownerPath, error); });
         const before = await handle.stat({ bigint: true });
         const modifiedAtMs = Math.max(directoryModifiedAtMs, Number(before.mtimeMs));
         const hasReadableRecord = before.isFile() &&

package/dist/src/runtime/adapters/long-term-memory/file-lock/path-observation.d.ts

@@ -0,0 +1,3 @@
+/** Only confirmed disappearance can normalize a Windows pending-delete denial. */
+export declare function observeLockReadFailure(path: string, error: unknown): Promise<unknown>;
+export declare function isWindowsLockReadDenial(error: unknown): boolean;

package/dist/src/runtime/adapters/long-term-memory/file-lock/path-observation.js

@@ -0,0 +1,20 @@
+import { lstat } from "node:fs/promises";
+import { fileSystemErrorCode } from "./contracts.js";
+/** Only confirmed disappearance can normalize a Windows pending-delete denial. */
+export async function observeLockReadFailure(path, error) {
+    if (!isWindowsLockReadDenial(error))
+        return error;
+    try {
+        await lstat(path);
+    }
+    catch (observedError) {
+        if (fileSystemErrorCode(observedError) === "ENOENT")
+            return observedError;
+    }
+    return error;
+}
+export function isWindowsLockReadDenial(error) {
+    if (process.platform !== "win32")
+        return false;
+    return fileSystemErrorCode(error) === "EPERM";
+}

package/dist/src/runtime/adapters/long-term-memory/file-lock/snapshot.js

@@ -2,6 +2,7 @@ import { lstat, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { directorySnapshot, fileSystemErrorCode, LEASE_DIRECTORY_NAME, OWNER_FILE_PATTERN, } from "./contracts.js";
 import { readOwnerRecord } from "./owner-record.js";
+import { observeLockReadFailure } from "./path-observation.js";
 export async function readLockSnapshot(lockPath) {
     const lockInfo = await readLockInfo(lockPath);
     if (!lockInfo)
@@ -13,7 +14,8 @@ export async function readLockSnapshot(lockPath) {
     try {
         lockEntries = await readdir(lockPath, { withFileTypes: true });
     }
-    catch (error) {
+    catch (readError) {
+        const error = await observeLockReadFailure(lockPath, readError);
         const code = fileSystemErrorCode(error);
         if (code === "ENOENT")
             return undefined;
@@ -45,7 +47,8 @@ async function readLockInfo(lockPath) {
     try {
         return await lstat(lockPath);
     }
-    catch (error) {
+    catch (readError) {
+        const error = await observeLockReadFailure(lockPath, readError);
         if (fileSystemErrorCode(error) === "ENOENT")
             return undefined;
         throw error;
@@ -62,7 +65,8 @@ async function readLeaseSnapshot(lockPath, lockModifiedAtMs) {
         }
         leaseEntries = await readdir(leasePath, { withFileTypes: true });
     }
-    catch (error) {
+    catch (readError) {
+        const error = await observeLockReadFailure(leasePath, readError);
         if (fileSystemErrorCode(error) === "ENOENT") {
             return invalidLeaseSnapshot(lockModifiedAtMs);
         }

package/dist/src/runtime/adapters/passive-learning-runtime.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeConfig, ModelGatewayClient, SessionStore } from "../ports.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 import type { SessionRequestAdmission } from "../request/session-admission.js";
-/** The environment owns learning; the paired desktop owns native collection. */
+/** The environment owns learning; the collection adapter owns the selected desktop source. */
 export declare function createRuntimePassiveLearning(params: {
     config: RuntimeConfig;
     models: ModelGatewayClient;

package/dist/src/runtime/adapters/passive-learning-runtime.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { connectHostObservations } from "../../computer-access/companion/observation-client.js";
+import { connectRuntimeObservations } from "./runtime-observation-connection.js";
 import { createPassiveLearningService } from "../passive-learning/service.js";
 import { createRuntimePassiveLearningModel } from "../passive-learning/model.js";
 import { createCoWorkerResourceDependencies } from "./co-worker-resources.js";
-/** The environment owns learning; the paired desktop owns native collection. */
+/** The environment owns learning; the collection adapter owns the selected desktop source. */
 export function createRuntimePassiveLearning(params) {
     const { config, models, memory } = params;
     const ownerId = createHash("sha256")
@@ -19,7 +19,7 @@ export function createRuntimePassiveLearning(params) {
             config, models, memory, context, ownerId, directory: join(config.paths.runtimeDir, "passive-learning"),
             sessions: params.sessions, deliveryAdmission: params.deliveryAdmission,
         }),
-        connect: (input) => connectHostObservations({
+        connect: (input) => connectRuntimeObservations({
             ...input,
             ownerId,
             rootDir: config.paths.rootDir,

package/dist/src/runtime/adapters/runtime-observation-connection.d.ts

@@ -0,0 +1,5 @@
+import type { HostObservationSubscription } from "../../shared/passive-observation.js";
+/** Installation consent gates every collection route before transport or helper startup. */
+export declare function connectRuntimeObservations(options: HostObservationSubscription): Promise<Readonly<{
+    close(): void;
+}>>;

package/dist/src/runtime/adapters/runtime-observation-connection.js

@@ -0,0 +1,13 @@
+import { connectHostObservations } from "../../computer-access/companion/observation-client.js";
+import { connectNativeObservations } from "../../computer-access/native-observation-connection.js";
+import { requireCollectionConsent } from "../../computer-access/collection-consent.js";
+import { readRuntimeCollectionSource } from "../../computer-access/observation-source.js";
+/** Installation consent gates every collection route before transport or helper startup. */
+export async function connectRuntimeObservations(options) {
+    options.abortSignal.throwIfAborted();
+    await requireCollectionConsent(options.rootDir);
+    options.abortSignal.throwIfAborted();
+    if (readRuntimeCollectionSource().mode === "native")
+        return connectNativeObservations(options);
+    return connectHostObservations(options);
+}

package/dist/src/runtime/local-host/windows-private-access.js

@@ -2,7 +2,9 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execute = promisify(execFile);
 // Paths travel through an environment value, never through shell interpolation.
+// PowerShell 7 callers can pass incompatible modules to Windows PowerShell 5.1.
 const privateAccessScript = `
+$env:PSModulePath = "$PSHOME\\Modules"
 $ErrorActionPreference = 'Stop'
 $target = $env:ABOT_LOCAL_HOST_PRIVATE_PATH
 $current = [System.Security.Principal.WindowsIdentity]::GetCurrent().User

package/dist/src/runtime/passive-learning/application-catalog.js

@@ -1,4 +1,5 @@
 import { isLearningApplicationExcluded, learningApplicationKey } from "./application-policy.js";
+import { isOwnObservationApplication } from "../../shared/passive-observation-self-exclusion.js";
 /** Derived metadata only; counts cover retained observations, never lifetime usage. */
 export function learningApplicationCatalog(queued, history, preferences) {
     const rows = new Map();
@@ -18,7 +19,8 @@ export function learningApplicationCatalog(queued, history, preferences) {
             row.lastObservedAt = observation.timestamp;
         rows.set(key, row);
     }
-    const summaries = [...rows.values()].map((row) => ({ ...row,
+    const configurable = [...rows.values()].filter((row) => !isOwnObservationApplication(learningApplicationKey(row.app)));
+    const summaries = configurable.map((row) => ({ ...row,
         collectionExcluded: isLearningApplicationExcluded(row.app, preferences.excludedApplications),
         processingExcluded: isLearningApplicationExcluded(row.app, preferences.processingExcludedApplications),
     }));

package/dist/src/runtime/passive-learning/collection-source.js

@@ -12,6 +12,11 @@ function shouldReconnectCollectionSource(event) {
         return true;
     return event.reason === "collector_start_failed";
 }
+function requiresCollectionConsent(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.message === "collection_consent_required";
+}
 function hasHealthyCollectionEvent(event) {
     if (event.type === "observation")
         return true;
@@ -66,6 +71,8 @@ export class LearningCollectionSource {
             if (abort.signal.aborted)
                 return;
             this.options.failed(error);
+            if (requiresCollectionConsent(error))
+                return;
             this.reconnect();
         }
     }

package/dist/src/runtime/passive-learning/service.js

@@ -16,7 +16,7 @@ import { LearningJournal } from "./journal.js";
 import { ObservationQueue } from "./queue.js";
 import { canProcessLearningObservation, isLearningApplicationExcluded } from "./application-policy.js";
 import { commitLearningApplicationPreferences } from "./application-controls.js";
-import { learningFailureReason, summarizeBatch, } from "./status-projection.js";
+import { learningFailureReason, learningCollectionFailureState, summarizeBatch, } from "./status-projection.js";
 import { DEFAULT_LEARNING_PREFERENCES, normalizeLearningPreferences, } from "./store.js";
 export function createPassiveLearningService(options) {
     const service = new LearningService(options);
@@ -447,8 +447,7 @@ class LearningService {
     }
     failFeature(error) {
         this.reason = learningFailureReason(error);
-        this.state =
-            this.reason === "learning_host_unavailable" ? "unavailable" : "failed";
+        this.state = learningCollectionFailureState(this.reason);
         this.changed();
     }
     failProcessing(error) {

package/dist/src/runtime/passive-learning/status-projection.d.ts

@@ -1,3 +1,4 @@
+import type { PassiveCollectionState } from "../../shared/passive-observation.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 import type { LearningBatch, LearningBatchSummary } from "./contracts.js";
 export declare function summarizeBatch({ observations, reviewProgress: _reviewProgress, ...summary }: LearningBatch): LearningBatchSummary;
@@ -7,4 +8,5 @@ export declare function recentLearningMemories(memory: LongTermMemoryService, hi
     content: string;
     createdAt: string;
 }>[]>;
+export declare function learningCollectionFailureState(reason: string): PassiveCollectionState;
 export declare function learningFailureReason(error: unknown): string;

package/dist/src/runtime/passive-learning/status-projection.js

@@ -36,6 +36,13 @@ export async function recentLearningMemories(memory, history) {
         return [];
     }
 }
+export function learningCollectionFailureState(reason) {
+    if (reason === "collection_consent_required")
+        return "permission_required";
+    if (reason === "learning_host_unavailable")
+        return "unavailable";
+    return "failed";
+}
 export function learningFailureReason(error) {
     if (!(error instanceof Error))
         return "learning_failed";
@@ -48,6 +55,8 @@ export function learningFailureReason(error) {
         "learning_model_profile_overridden",
         "learning_memory_unavailable",
         "learning_host_unavailable",
+        "collection_consent_required",
+        "native_observation_identity_invalid",
         "learning_storage_unavailable",
         "learning_batch_timeout",
         "learning_disabled",

package/dist/src/runtime/plugins/installation/package.d.ts

@@ -10,6 +10,7 @@ export declare function preparePluginPackage(rootDir: string, source: PluginInst
         description?: string;
         extensions: Readonly<{
             [ABOT_RUNTIME_EXTENSION]: import("../../../plugin-contract/manifest.js").AbotRuntimePluginExtension;
+            ["ai.abot.compatibility"]?: import("../../../plugin-contract/platform-compatibility.js").PluginPlatformDeclaration;
             [namespace: string]: unknown;
         }>;
     }>;
@@ -23,6 +24,13 @@ export declare function preparePluginPackage(rootDir: string, source: PluginInst
         };
         digest: string;
         id: string;
+        compatibility: Readonly<{
+            supported: boolean;
+            status: "declared" | "legacy" | "unsupported" | "undeclared";
+            runtimePlatform: NodeJS.Platform;
+            runtimePlatforms?: readonly import("../../../plugin-contract/platform-compatibility.js").PluginRuntimePlatform[];
+            reason?: string;
+        }>;
         version: string;
         description: string;
         capabilities: {

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

@@ -2,6 +2,7 @@ import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { PluginInstallError, } from "../../../plugin-contract/install-source.js";
 import { ABOT_RUNTIME_EXTENSION } from "../../../plugin-contract/manifest.js";
+import { resolvePluginPlatformCompatibility } from "../platform-compatibility.js";
 import { parseAgentPluginManifest } from "../manifest-validator.js";
 import { projectManifestRuntimeContract } from "../manifest-projection.js";
 import { discoverConfiguredRuntimePluginManifests } from "../configured-manifests.js";
@@ -42,6 +43,7 @@ export async function preparePluginPackage(rootDir, source, download = downloadG
                 source: downloaded.source,
                 digest,
                 id: manifest.name,
+                compatibility: resolvePluginPlatformCompatibility(manifest),
                 version: manifest.version ?? "",
                 description: manifest.description ?? "",
                 capabilities: capabilities.map((id) => ({

package/dist/src/runtime/plugins/installation/service.d.ts

@@ -10,6 +10,13 @@ export declare function inspectPluginPackage(rootDir: string, input: unknown, do
     };
     digest: string;
     id: string;
+    compatibility: Readonly<{
+        supported: boolean;
+        status: "declared" | "legacy" | "unsupported" | "undeclared";
+        runtimePlatform: NodeJS.Platform;
+        runtimePlatforms?: readonly import("../../../plugin-contract/platform-compatibility.js").PluginRuntimePlatform[];
+        reason?: string;
+    }>;
     version: string;
     description: string;
     capabilities: {

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

@@ -11,6 +11,7 @@ import { discoverAgentPluginManifests } from "./manifest-discovery.js";
 import { resolveBundledRuntimeRoot } from "./bundled-root.js";
 import { projectManifestRuntimeContract } from "./manifest-projection.js";
 import { discoverConfiguredRuntimePluginManifests } from "./configured-manifests.js";
+import { resolvePluginPlatformCompatibility } from "./platform-compatibility.js";
 import { isPluginCatalogDisabled, isPluginToolSelected, normalizePluginSelection, pluginSelectionCacheKey, } from "./selection.js";
 const require = createRequire(import.meta.url);
 const compiledCatalogCache = new WeakMap();
@@ -110,20 +111,15 @@ export function loadConfiguredRuntimePlugins(config) {
     if (cached) {
         return cached;
     }
-    const host = {
-        rootDir: config.paths.rootDir,
-        pluginConfiguration: readPluginConfigurationStore(config.paths.rootDir)
-            .plugins,
-        runtimeId: config.runtimeId,
-        agentBridgeUrl: config.agentBridgeUrl,
-        runtimePaths: config.paths,
-    };
-    const manifestPlugins = discoverConfiguredRuntimePluginManifests(config.paths.rootDir, {
+    const discoveredPlugins = discoverConfiguredRuntimePluginManifests(config.paths.rootDir, {
         excludedPluginIds: new Set([
             ...selection.deny,
             ...selection.disabledPluginIds,
         ]),
-    })
+    });
+    const compatiblePlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
+    const allPluginsIncompatible = discoveredPlugins.length > 0 && compatiblePlugins.length === 0;
+    const selectedPlugins = compatiblePlugins
         .map((plugin) => ({
         plugin,
         selectedCapabilityIds: Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities).filter((capabilityId) => isPluginToolSelected({
@@ -132,8 +128,17 @@ export function loadConfiguredRuntimePlugins(config) {
             selection,
         })),
     }))
-        .filter(({ selectedCapabilityIds }) => selectedCapabilityIds.length > 0)
-        .map(({ plugin, selectedCapabilityIds }) => loadManifestRuntimePlugin(host, plugin, selectedCapabilityIds));
+        .filter(({ selectedCapabilityIds }) => selectedCapabilityIds.length > 0);
+    const host = {
+        rootDir: config.paths.rootDir,
+        pluginConfiguration: allPluginsIncompatible
+            ? {}
+            : readPluginConfigurationStore(config.paths.rootDir).plugins,
+        runtimeId: config.runtimeId,
+        agentBridgeUrl: config.agentBridgeUrl,
+        runtimePaths: config.paths,
+    };
+    const manifestPlugins = selectedPlugins.map(({ plugin, selectedCapabilityIds }) => loadManifestRuntimePlugin(host, plugin, selectedCapabilityIds));
     const pluginIds = new Set();
     for (const plugin of manifestPlugins) {
         if (pluginIds.has(plugin.id)) {
@@ -175,14 +180,19 @@ export function loadBundledRuntimePlugins() {
     if (cached) {
         return cached;
     }
+    const discoveredPlugins = discoverAgentPluginManifests(packageRoot);
+    const selectedPlugins = discoveredPlugins.filter((plugin) => resolvePluginPlatformCompatibility(plugin.manifest).supported);
+    const allPluginsIncompatible = discoveredPlugins.length > 0 && selectedPlugins.length === 0;
     const host = {
         rootDir,
-        pluginConfiguration: readPluginConfigurationStore(rootDir).plugins,
+        pluginConfiguration: allPluginsIncompatible
+            ? {}
+            : readPluginConfigurationStore(rootDir).plugins,
         runtimeId: "default",
         agentBridgeUrl: "",
         runtimePaths: createUnconfiguredRuntimePaths(rootDir),
     };
-    const catalog = Object.freeze(discoverAgentPluginManifests(packageRoot).map((plugin) => freezeRuntimePlugin(loadManifestRuntimePlugin(host, plugin, Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities)))));
+    const catalog = Object.freeze(selectedPlugins.map((plugin) => freezeRuntimePlugin(loadManifestRuntimePlugin(host, plugin, Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities)))));
     bundledCatalogCache.set(cacheKey, catalog);
     return catalog;
 }

package/dist/src/runtime/plugins/manifest-platform-compatibility.d.ts

@@ -0,0 +1,2 @@
+import { type PluginPlatformDeclaration } from "../../plugin-contract/platform-compatibility.js";
+export declare function parsePluginPlatformDeclaration(value: unknown): PluginPlatformDeclaration | undefined;

package/dist/src/runtime/plugins/manifest-platform-compatibility.js

@@ -0,0 +1,39 @@
+import { ABOT_PLUGIN_COMPATIBILITY_EXTENSION, ABOT_PLUGIN_COMPATIBILITY_VERSION, PLUGIN_RUNTIME_PLATFORMS, } from "../../plugin-contract/platform-compatibility.js";
+import { isRecord } from "../config/utils.js";
+function hasUnknownCompatibilityField(value) {
+    return Object.keys(value).some((key) => key !== "version" && key !== "runtimePlatforms");
+}
+function isRuntimePlatformList(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length === 0)
+        return false;
+    return value.length <= PLUGIN_RUNTIME_PLATFORMS.length;
+}
+function isPluginRuntimePlatform(value) {
+    return PLUGIN_RUNTIME_PLATFORMS.some((platform) => platform === value);
+}
+function hasRepeatedRuntimePlatform(platforms) {
+    return new Set(platforms).size !== platforms.length;
+}
+export function parsePluginPlatformDeclaration(value) {
+    if (value === undefined)
+        return undefined;
+    const path = `extensions.${ABOT_PLUGIN_COMPATIBILITY_EXTENSION}`;
+    if (!isRecord(value))
+        throw new Error(`${path} must be an object`);
+    if (hasUnknownCompatibilityField(value))
+        throw new Error(`${path} contains an unknown field`);
+    if (value.version !== ABOT_PLUGIN_COMPATIBILITY_VERSION)
+        throw new Error(`${path}.version must be ${ABOT_PLUGIN_COMPATIBILITY_VERSION}`);
+    if (!isRuntimePlatformList(value.runtimePlatforms))
+        throw new Error(`${path}.runtimePlatforms must contain one to three platforms`);
+    if (!value.runtimePlatforms.every(isPluginRuntimePlatform))
+        throw new Error(`${path}.runtimePlatforms must use linux, darwin, or win32`);
+    if (hasRepeatedRuntimePlatform(value.runtimePlatforms))
+        throw new Error(`${path}.runtimePlatforms must not contain duplicates`);
+    return Object.freeze({
+        version: ABOT_PLUGIN_COMPATIBILITY_VERSION,
+        runtimePlatforms: Object.freeze([...value.runtimePlatforms]),
+    });
+}

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

@@ -1,5 +1,7 @@
 import { parseOptionalToolOutputChannels } from "../../capabilities/normal-invocation/output-channels.js";
 import { parseRequiredToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+import { ABOT_PLUGIN_COMPATIBILITY_EXTENSION } from "../../plugin-contract/platform-compatibility.js";
+import { parsePluginPlatformDeclaration } from "./manifest-platform-compatibility.js";
 import { isToolCatalogGroupId } from "../../capabilities/tool-types.js";
 import { parseEventResultMetadata } from "../../capabilities/tool-definition-validator/event-result-metadata.js";
 import { parseEventInputTextOptions } from "../../capabilities/tool-definition-validator/event-input-text-options.js";
@@ -321,7 +323,9 @@ function parseOperation(value, path) {
                 ? { payload: payload }
                 : {}),
             ...(attachmentInput
-                ? { attachmentInput: attachmentInput }
+                ? {
+                    attachmentInput: attachmentInput,
+                }
                 : {}),
         },
         ...(legacySkills ? { legacySkills } : {}),
@@ -481,6 +485,7 @@ export function parseAgentPluginManifest(raw, folderName) {
     }
     const extensions = expectRecord(manifest.extensions, "plugin.json.extensions");
     const runtimeExtension = parseRuntimeExtension(extensions[ABOT_RUNTIME_EXTENSION]);
+    const compatibility = parsePluginPlatformDeclaration(extensions[ABOT_PLUGIN_COMPATIBILITY_EXTENSION]);
     return {
         $schema: AGENT_PLUGIN_MANIFEST_SCHEMA,
         name: manifest.name,
@@ -493,6 +498,9 @@ export function parseAgentPluginManifest(raw, folderName) {
         extensions: {
             ...extensions,
             [ABOT_RUNTIME_EXTENSION]: runtimeExtension,
+            ...(compatibility
+                ? { [ABOT_PLUGIN_COMPATIBILITY_EXTENSION]: compatibility }
+                : {}),
         },
     };
 }

package/dist/src/runtime/plugins/platform-compatibility.d.ts

@@ -0,0 +1,4 @@
+import type { AgentPluginManifest } from "../../plugin-contract/manifest.js";
+import { type PluginPlatformCompatibility } from "../../plugin-contract/platform-compatibility.js";
+/** Compatibility affects loading, never the user's saved plugin selection. */
+export declare function resolvePluginPlatformCompatibility(manifest: AgentPluginManifest, runtimePlatform?: NodeJS.Platform): PluginPlatformCompatibility;

package/dist/src/runtime/plugins/platform-compatibility.js

@@ -0,0 +1,44 @@
+import { ABOT_PLUGIN_COMPATIBILITY_EXTENSION, } from "../../plugin-contract/platform-compatibility.js";
+function runtimePlatformName(platform) {
+    if (platform === "win32")
+        return "Windows";
+    if (platform === "darwin")
+        return "macOS";
+    if (platform === "linux")
+        return "Linux";
+    return platform;
+}
+function supportsDeclaredRuntimePlatform(declaration, runtimePlatform) {
+    return declaration.runtimePlatforms.some((platform) => platform === runtimePlatform);
+}
+function undeclaredPlatformCompatibility(runtimePlatform) {
+    if (runtimePlatform === "win32")
+        return {
+            supported: false,
+            status: "undeclared",
+            runtimePlatform,
+            reason: "This plugin does not declare support for Windows Runtime.",
+        };
+    return { supported: true, status: "legacy", runtimePlatform };
+}
+/** Compatibility affects loading, never the user's saved plugin selection. */
+export function resolvePluginPlatformCompatibility(manifest, runtimePlatform = process.platform) {
+    const declaration = manifest.extensions[ABOT_PLUGIN_COMPATIBILITY_EXTENSION];
+    if (!declaration)
+        return undeclaredPlatformCompatibility(runtimePlatform);
+    const runtimePlatforms = declaration.runtimePlatforms;
+    if (supportsDeclaredRuntimePlatform(declaration, runtimePlatform))
+        return {
+            supported: true,
+            status: "declared",
+            runtimePlatform,
+            runtimePlatforms,
+        };
+    return {
+        supported: false,
+        status: "unsupported",
+        runtimePlatform,
+        runtimePlatforms,
+        reason: `This plugin supports Runtime on ${runtimePlatforms.map(runtimePlatformName).join(", ")}; this Runtime is running on ${runtimePlatformName(runtimePlatform)}.`,
+    };
+}

package/dist/src/runtime/request/approval-wait/activation-events.js

@@ -45,13 +45,22 @@ export class RequestActivationEvents {
     }
     async commit(operation) {
         await this.events.drain();
-        const result = await operation(this.expectation());
-        if (!result.accepted)
-            throw new Error(`request_lifecycle_rejected:${result.reason}`);
-        this.current = result.current;
-        this.sealed = result.current.status !== "streaming";
-        this.publishCommitted(result.events);
-        return result;
+        // Draining is an observation, not a queue reservation: steering can emit
+        // another event before this continuation runs. Claim this same queue before
+        // reading the revision so no event can race the lifecycle commit.
+        const committed = this.tail.then(async () => {
+            if (this.persistenceError)
+                throw this.persistenceError;
+            const result = await operation(this.expectation());
+            if (!result.accepted)
+                throw new Error(`request_lifecycle_rejected:${result.reason}`);
+            this.current = result.current;
+            this.sealed = result.current.status !== "streaming";
+            this.publishCommitted(result.events);
+            return result;
+        });
+        this.tail = committed.then(() => undefined, () => undefined);
+        return committed;
     }
     /** A failed event write cannot turn a committed wait into an execution failure. */
     async finalizeFailure(input) {
@@ -115,6 +124,9 @@ export class RequestActivationEvents {
             return;
         this.tail = this.tail
             .then(async () => {
+            const hasStreamingActivation = this.current.status === "streaming";
+            if (!hasStreamingActivation)
+                return;
             if (this.persistenceError)
                 return;
             const result = await this.store.appendActivationEvent(this.current.sessionId, {

package/dist/src/runtime/request/approval-wait/execution-compaction-restore.d.ts

@@ -0,0 +1,20 @@
+import type { RequestContextCompactionSnapshot } from "../../context/semantic-compaction/snapshot.js";
+import type { SemanticCompactionSource } from "../../context/semantic-compaction/contracts.js";
+import type { RoleCallLedgerCheckpoint } from "../../orchestration/role-calls/checkpoint.js";
+import type { CompiledRequestExecutionPolicy } from "../execution-scope.js";
+/** Invalidate only proven legacy EA projections; the ledger retains the original evidence. */
+export declare function restoreExecutionApprovalCompaction(params: {
+    snapshot: RequestContextCompactionSnapshot;
+    ledgerCheckpoint: RoleCallLedgerCheckpoint;
+    requestId: string;
+    executionPolicy: CompiledRequestExecutionPolicy;
+}): Readonly<{
+    snapshot?(): RequestContextCompactionSnapshot;
+    get(scopeId: string): import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint | undefined;
+    findByCallIds(callIds: readonly string[]): readonly import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint[];
+    registerSources(sources: readonly SemanticCompactionSource[]): void;
+    registerSourcesAtomically?(sources: readonly SemanticCompactionSource[]): void;
+    quarantineScope?(record: import("../../context/semantic-compaction/scope-quarantine.js").InvalidatedCompactionScope): void;
+    materializeSource(sourceRef: string, sourceFingerprint: string): SemanticCompactionSource | undefined;
+    commit(checkpoint: import("../../context/semantic-compaction/contracts.js").SemanticCompactionCheckpoint): void;
+}>;