@abot-ai/runtime 1.6.0 → 1.8.0

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/plugins/selection.d.ts

@@ -3,9 +3,11 @@ export type PluginSelection = Readonly<{
     enabled: boolean;
     allow: readonly string[];
     deny: readonly string[];
+    disabledPluginIds: readonly string[];
 }>;
 export declare function normalizePluginSelection(config: RuntimePluginConfig | undefined): PluginSelection;
 export declare function pluginSelectionCacheKey(selection: PluginSelection): string;
+export declare function isPluginDisabledById(pluginId: string, selection: PluginSelection): boolean;
 export declare function isPluginCatalogDisabled(selection: PluginSelection): boolean;
 export declare function isPluginToolSelected(params: {
     pluginId: string;

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

@@ -1,3 +1,4 @@
+import { matchesToolSelectionId } from "../../shared/tool-selection.js";
 function uniqueSorted(values) {
     return [
         ...new Set((values ?? [])
@@ -10,29 +11,33 @@ export function normalizePluginSelection(config) {
         enabled: config?.enabled !== false,
         allow: Object.freeze(uniqueSorted(config?.allow)),
         deny: Object.freeze(uniqueSorted(config?.deny)),
+        disabledPluginIds: Object.freeze(uniqueSorted(config?.disabledPluginIds)),
     });
 }
 export function pluginSelectionCacheKey(selection) {
-    return JSON.stringify([selection.enabled, selection.allow, selection.deny]);
+    return JSON.stringify([
+        selection.enabled,
+        selection.allow,
+        selection.deny,
+        selection.disabledPluginIds,
+    ]);
+}
+export function isPluginDisabledById(pluginId, selection) {
+    return selection.disabledPluginIds.includes(pluginId);
 }
 export function isPluginCatalogDisabled(selection) {
     if (!selection.enabled)
         return true;
     return selection.deny.includes("*");
 }
-function matchesPluginToolId(pluginId, toolName, configuredId) {
-    return (configuredId === "*" ||
-        configuredId === pluginId ||
-        configuredId === toolName ||
-        configuredId === `${pluginId}.${toolName}`);
-}
 export function isPluginToolSelected(params) {
-    if (!params.selection.enabled) {
+    if (!params.selection.enabled)
+        return false;
+    if (isPluginDisabledById(params.pluginId, params.selection))
         return false;
-    }
     if (params.selection.allow.length > 0 &&
-        !params.selection.allow.some((entry) => matchesPluginToolId(params.pluginId, params.toolName, entry))) {
+        !params.selection.allow.some((entry) => matchesToolSelectionId(params.pluginId, params.toolName, entry))) {
         return false;
     }
-    return !params.selection.deny.some((entry) => matchesPluginToolId(params.pluginId, params.toolName, entry));
+    return !params.selection.deny.some((entry) => matchesToolSelectionId(params.pluginId, params.toolName, entry));
 }

package/dist/src/runtime/ports.d.ts

@@ -44,6 +44,8 @@ export type RuntimeRequestRunnerConfig = {
     configPath: string;
 };
 export type RuntimePluginConfig = {
+    /** Exact plugin IDs; never interpreted as capability IDs or wildcards. */
+    disabledPluginIds?: string[];
     enabled?: boolean;
     allow?: string[];
     deny?: string[];
@@ -60,6 +62,9 @@ export type RuntimeConfig = {
     agentBridgeToken?: string;
     modelGatewayUrl: string;
     paths: RuntimePaths;
+    webUi?: {
+        pageSize: number;
+    };
     logging?: RuntimeLoggingConfig;
     timeouts?: RuntimeTimeouts;
     plugins?: RuntimePluginConfig;
@@ -129,10 +134,7 @@ export type SessionStore = SessionMemoryRepository & {
         cursor?: string | null;
     }) => Promise<SessionListResult>;
     getSessionById: (sessionId: string) => Promise<SessionRecord | null>;
-    getSessionSnapshot: (sessionId: string, options?: {
-        afterMessageId?: string | number | null;
-        includeRequests?: boolean;
-    }) => Promise<SessionSnapshot | null>;
+    getSessionSnapshot: (sessionId: string, options?: import("../sessions/snapshot.js").SessionSnapshotOptions) => Promise<SessionSnapshot | null>;
     getRequestReplayById: (requestId: string, afterSeq?: number) => Promise<SessionRequestReplay | null>;
     updateSessionTitle: (sessionId: string, title: string) => Promise<SessionRecord | null>;
     updateSessionRuntimeMode?: (sessionId: string, runtimeModeId: string | null) => Promise<SessionRecord | null>;

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

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

@@ -0,0 +1,118 @@
+import { restoreRequestContextCompaction } from "../../context/semantic-compaction/snapshot.js";
+import { createRoleCallLedger, } from "../../orchestration/role-calls/index.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { createRequestRoleCallPolicy } from "../role-call-policy.js";
+import { buildExecutionCapabilityResultMessage, EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND, EXECUTION_CAPABILITY_TOOL_NAME, } from "../../steps/execution-agent/capability-result-context.js";
+/** Invalidate only proven legacy EA projections; the ledger retains the original evidence. */
+export function restoreExecutionApprovalCompaction(params) {
+    // Validate original hashes and complete checkpoint coverage before filtering anything.
+    const restored = restoreRequestContextCompaction(params.snapshot);
+    if (!usesExecutionAgentNativeResults(params.executionPolicy))
+        return restored;
+    if (!params.snapshot.sources.some(isNativeResultCompatibilityCandidate))
+        return restored;
+    const ledger = createRoleCallLedger({
+        requestId: params.requestId,
+        policy: createRequestRoleCallPolicy(params.executionPolicy),
+        checkpoint: params.ledgerCheckpoint,
+    });
+    const head = ledger.current();
+    const executions = new Map(head.state.capabilityExecutions
+        .filter((execution) => execution.callId === head.state.rootCallId)
+        .map((execution) => [`tool-result:${execution.executionId}`, execution]));
+    const legacySourceRefs = new Set();
+    for (const source of params.snapshot.sources) {
+        const execution = executions.get(source.sourceRef);
+        if (!isExecutionResultSource(source, execution))
+            continue;
+        if (!isSettledRootExecution(execution, head.state.rootCallId))
+            throw new Error("context_compaction_snapshot_source_incompatible");
+        const current = buildExecutionCapabilityResultMessage(head, execution);
+        const matchesCurrentProjection = source.content === JSON.stringify(current);
+        if (matchesCurrentProjection)
+            continue;
+        const matchesLegacyProjection = source.content === serializeLegacyExecutionResult(execution);
+        if (!matchesLegacyProjection)
+            throw new Error("context_compaction_snapshot_source_incompatible");
+        legacySourceRefs.add(source.sourceRef);
+    }
+    if (legacySourceRefs.size === 0)
+        return restored;
+    const invalidatedCheckpoints = params.snapshot.checkpoints.filter((checkpoint) => checkpoint.sourceDigests.some((source) => legacySourceRefs.has(source.sourceRef)));
+    const ownsInvalidatedCheckpoints = invalidatedCheckpoints.every((checkpoint) => checkpoint.requestId === params.requestId);
+    if (!ownsInvalidatedCheckpoints)
+        throw new Error("context_compaction_snapshot_source_incompatible");
+    const compatible = {
+        ...params.snapshot,
+        sources: params.snapshot.sources.filter((source) => !legacySourceRefs.has(source.sourceRef)),
+        checkpoints: params.snapshot.checkpoints.filter((checkpoint) => !invalidatedCheckpoints.includes(checkpoint)),
+    };
+    const store = restoreRequestContextCompaction(compatible);
+    traceDebug("runtime.approvals", "compaction.legacy_execution_sources_invalidated", {
+        requestId: params.requestId,
+        sourceCount: legacySourceRefs.size,
+        checkpointCount: invalidatedCheckpoints.length,
+        scopeIds: invalidatedCheckpoints
+            .slice(0, 8)
+            .map(({ scopeId }) => scopeId),
+        omittedScopeCount: Math.max(0, invalidatedCheckpoints.length - 8),
+    });
+    return store;
+}
+function usesExecutionAgentNativeResults(policy) {
+    if (policy.authority.id !== "execution-agent-v1")
+        return false;
+    return policy.authority.rootContractId === "execution_agent";
+}
+function isSettledRootExecution(execution, rootCallId) {
+    if (!execution)
+        return false;
+    if (execution.callId !== rootCallId)
+        return false;
+    return execution.status === "settled";
+}
+function isNativeResultCompatibilityCandidate(source) {
+    if (source.sourceRef.startsWith("tool-result:"))
+        return true;
+    return hasExecutionResultEnvelope(source);
+}
+function isExecutionResultSource(source, execution) {
+    if (execution)
+        return true;
+    return hasExecutionResultEnvelope(source);
+}
+function hasExecutionResultEnvelope(source) {
+    try {
+        const message = JSON.parse(source.content);
+        if (message?.role !== "tool")
+            return false;
+        if (message.toolName !== EXECUTION_CAPABILITY_TOOL_NAME)
+            return false;
+        if (typeof message.content !== "string")
+            return false;
+        const envelope = JSON.parse(message.content);
+        return envelope?.kind === EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND;
+    }
+    catch {
+        return false;
+    }
+}
+/** Exact pre-canonical-outcome wire bytes, recognized only against the same ledger execution. */
+function serializeLegacyExecutionResult(execution) {
+    return JSON.stringify({
+        role: "tool",
+        content: JSON.stringify({
+            kind: EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND,
+            authority: "capability_adapter_result",
+            presenceEffect: "runtime_result_only_not_user_intent",
+            invocationAttempt: execution.invocationAttempt,
+            result: {
+                executionId: execution.executionId,
+                capabilityId: execution.capabilityId,
+                adapterResult: execution.exactResult,
+            },
+        }),
+        toolCallId: execution.executionId,
+        toolName: EXECUTION_CAPABILITY_TOOL_NAME,
+    });
+}

package/dist/src/runtime/request/approval-wait/super-compaction-restore.js

@@ -1,3 +1,4 @@
+import { restoreExecutionApprovalCompaction } from "./execution-compaction-restore.js";
 import { createRoleCallLedger } from "../../orchestration/role-calls/index.js";
 import { hasSuperContextContract } from "../../context/super-context-policy.js";
 import { createOwnedSuperContextFailure } from "../../context/super-context-failure.js";
@@ -8,7 +9,7 @@ import { createRequestRoleCallPolicy } from "../role-call-policy.js";
 export function restoreApprovalCompaction(params) {
     const { snapshot, executionPolicy } = params;
     if (!hasSuperContextContract(executionPolicy.authority, "supervisor"))
-        return restoreRequestContextCompaction(snapshot);
+        return restoreExecutionApprovalCompaction(params);
     const ledger = createRoleCallLedger({
         requestId: params.requestId,
         policy: createRequestRoleCallPolicy(executionPolicy),

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

@@ -18,7 +18,8 @@ export declare function resolveRequestDependencies(options: RequestHandlerOption
         runnerConfig: import("../config/runner/contracts.js").RequestRunnerConfig;
         modelPolicy: import("../../model-gateway/types.js").ModelGatewayPolicyConfig;
         modelExecutionPolicies: Readonly<Record<string, Readonly<{
-            policy: import("../config/model-execution-policy.js").RequestExecutionPolicyId;
+            policy?: import("../config/model-execution-policy.js").RequestExecutionPolicyId;
+            plugins?: import("../config/model-plugin-config.js").RuntimeModelPluginConfig;
         }>>> | undefined;
     };
 };

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

@@ -22,8 +22,8 @@ export declare function projectExecutionPayloadCompactedEvidence(request: Payloa
         adapterResult: import("../orchestration/capability-adapters/result.js").CapabilityAdapterResult;
     }> | Readonly<{
         compactedSourceRef: string;
-        capabilityId: string;
         summary: string;
+        capabilityId: string;
         callId: string;
         outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
         executionId: string;

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

@@ -7,6 +7,7 @@ import { isRequestCancelled, REQUEST_CANCELLED } from "./cancellation.js";
 import { isRequestInterrupted, REQUEST_INTERRUPTED } from "./interruption.js";
 import { RequestToolResources } from "../capabilities/request-tool-resources.js";
 import { traceDebug } from "../observability/debug-logger.js";
+import { traceRequestControl } from "../observability/request-control-diagnostics.js";
 import { RequestLifecycle } from "../orchestration/lifecycle/request-lifecycle.js";
 import { ROLE_CALL_RESPONSE_MAX_LENGTH } from "../orchestration/role-calls/index.js";
 import { runModelAuthoredDegradedFinalization } from "../steps/degraded-finalization/model-authored.js";
@@ -107,6 +108,13 @@ class RequestHandlingSession {
         }
     }
     async execute() {
+        traceRequestControl("runtime.request_control", "request.entered", {
+            requestId: this.input.requestId,
+            sessionId: this.input.sessionId,
+            environmentId: this.options.runtimeConfig?.runtimeId,
+            toolPermissionMode: this.input.toolPermissionMode,
+            resumed: Boolean(this.options.approvalExecution?.resume),
+        });
         const prepared = await prepareRequestExecution({
             ws: this.ws,
             options: this.options,

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

@@ -1,3 +1,5 @@
+import { bindRequestWorkingDirectory } from "../capabilities/request-working-directory.js";
+import { createRuntimeToolPathResolver } from "../capabilities/runtime-target-path.js";
 import { isSparkSession } from "../../sessions/spark-session.js";
 import { createSuperFailureFinalization, } from "./super-failure-explanation.js";
 import { resolveSessionWorkingDirectory } from "../projects/session-paths.js";
@@ -116,7 +118,9 @@ export async function prepareRequestExecution(params) {
         sessionId,
         prompt: initialized.prompt,
         temporalContext: params.temporalContext,
-        ...(isSparkSession(opened.session) ? { sessionKind: "spark" } : {}),
+        ...(isSparkSession(opened.session)
+            ? { sessionKind: "spark" }
+            : {}),
         historyMessages,
         shouldGenerateSessionTitle: generateSessionTitle,
         runnerConfig: loaded.runnerConfig,
@@ -198,6 +202,7 @@ export async function prepareRequestExecution(params) {
         : preparedSeed;
     const toolRegistry = options.toolRegistry?.prepareRequest
         ? await options.toolRegistry.prepareRequest({
+            runtimePathResolver: createRuntimeToolPathResolver(bindRequestWorkingDirectory(options.toolRegistry.prepareSharedState?.() ?? {}, requestWorkingDirectory).runtimePaths),
             requestState: resources.state,
             onRequestDispose: resources.onRequestDispose,
         })
@@ -214,6 +219,9 @@ export async function prepareRequestExecution(params) {
             requestWorkingDirectory,
             ...(filesystemScope ? { filesystemScope } : {}),
             executionPolicyAuthority: executionPolicy.authority,
+            ...(seed.executionPolicySelection?.plugins
+                ? { modelPlugins: seed.executionPolicySelection.plugins }
+                : {}),
             requestAttachments: toolAttachments,
             ...(options.runtimeConfig
                 ? { runtimeConfig: options.runtimeConfig }

package/dist/src/runtime/request/request-steering.d.ts

@@ -33,4 +33,8 @@ export declare function resolveRequestSteeringInbox(inbox: RequestSteeringInbox
 export declare function projectRequestSteeringSnapshot(inbox: RequestSteeringInbox | undefined, version: number): RequestSteeringSnapshot;
 export declare function createRequestSteeringInbox(params: {
     requestId: string;
+    diagnostics?: Readonly<{
+        inboxId?: string;
+        origin?: string;
+    }>;
 }): RequestSteeringInbox;

package/dist/src/runtime/request/request-steering.js

@@ -1,4 +1,4 @@
-import { traceDebug } from "../observability/debug-logger.js";
+import { createRequestControlDiagnosticId, traceRequestControl, } from "../observability/request-control-diagnostics.js";
 export const REQUEST_STEERING_FEATURE = "request_steering_v1";
 export const REQUEST_STEERING_MESSAGE_KIND = "runtime_active_request_updates_v1";
 const LOG_SCOPE = "runtime.request_steering";
@@ -30,6 +30,10 @@ export function projectRequestSteeringSnapshot(inbox, version) {
     });
 }
 export function createRequestSteeringInbox(params) {
+    const diagnosticIdentity = {
+        inboxId: params.diagnostics?.inboxId ?? createRequestControlDiagnosticId("inbox"),
+        inboxOrigin: params.diagnostics?.origin ?? "request",
+    };
     const updates = [];
     const bySteerId = new Map();
     let closed = false;
@@ -37,6 +41,10 @@ export function createRequestSteeringInbox(params) {
     let persistenceBound = false;
     let persistUpdate;
     let persistenceTail = Promise.resolve();
+    traceRequestControl(LOG_SCOPE, "inbox.opened", {
+        ...diagnosticIdentity,
+        requestId: params.requestId,
+    });
     function schedulePersistence(update) {
         if (!persistUpdate)
             return;
@@ -44,7 +52,8 @@ export function createRequestSteeringInbox(params) {
         persistenceTail = persistenceTail.then(async () => {
             try {
                 await persist(update);
-                traceDebug(LOG_SCOPE, "update.persisted", {
+                traceRequestControl(LOG_SCOPE, "update.persisted", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId: update.steerId,
                     sequence: update.sequence,
@@ -52,7 +61,8 @@ export function createRequestSteeringInbox(params) {
                 });
             }
             catch (error) {
-                traceDebug(LOG_SCOPE, "update.persistence_failed", {
+                traceRequestControl(LOG_SCOPE, "update.persistence_failed", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId: update.steerId,
                     sequence: update.sequence,
@@ -66,8 +76,10 @@ export function createRequestSteeringInbox(params) {
             const steerId = input.steerId.trim();
             const text = input.text.trim();
             if (!steerId || !text) {
-                traceDebug(LOG_SCOPE, "update.rejected", {
+                traceRequestControl(LOG_SCOPE, "update.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
+                    steerId,
                     reason: "invalid_steer_request",
                     steerIdLength: steerId.length,
                     textLength: text.length,
@@ -80,7 +92,8 @@ export function createRequestSteeringInbox(params) {
             const existing = bySteerId.get(steerId);
             if (existing) {
                 if (existing.text !== text) {
-                    traceDebug(LOG_SCOPE, "update.rejected", {
+                    traceRequestControl(LOG_SCOPE, "update.rejected", {
+                        ...diagnosticIdentity,
                         requestId: params.requestId,
                         steerId,
                         reason: "steer_id_conflict",
@@ -90,7 +103,8 @@ export function createRequestSteeringInbox(params) {
                         reason: "steer_id_conflict",
                     });
                 }
-                traceDebug(LOG_SCOPE, "update.duplicate", {
+                traceRequestControl(LOG_SCOPE, "update.duplicate", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId,
                     sequence: existing.sequence,
@@ -102,7 +116,8 @@ export function createRequestSteeringInbox(params) {
                 });
             }
             if (closed || sealed) {
-                traceDebug(LOG_SCOPE, "update.rejected", {
+                traceRequestControl(LOG_SCOPE, "update.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId,
                     reason: "request_not_active",
@@ -122,7 +137,8 @@ export function createRequestSteeringInbox(params) {
             updates.push(update);
             bySteerId.set(steerId, update);
             schedulePersistence(update);
-            traceDebug(LOG_SCOPE, "update.accepted", {
+            traceRequestControl(LOG_SCOPE, "update.accepted", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 steerId,
                 sequence: update.sequence,
@@ -144,7 +160,8 @@ export function createRequestSteeringInbox(params) {
             for (const update of updates) {
                 schedulePersistence(update);
             }
-            traceDebug(LOG_SCOPE, "persistence.bound", {
+            traceRequestControl(LOG_SCOPE, "persistence.bound", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 queuedUpdateCount: updates.length,
             });
@@ -156,8 +173,14 @@ export function createRequestSteeringInbox(params) {
             }
             closed = true;
             sealed = true;
+            traceRequestControl(LOG_SCOPE, "inbox.closing", {
+                ...diagnosticIdentity,
+                requestId: params.requestId,
+                updateCount: updates.length,
+            });
             await persistenceTail;
-            traceDebug(LOG_SCOPE, "inbox.closed", {
+            traceRequestControl(LOG_SCOPE, "inbox.closed", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 updateCount: updates.length,
             });
@@ -167,7 +190,8 @@ export function createRequestSteeringInbox(params) {
         },
         seal(version) {
             if (closed || sealed || updates.length !== version) {
-                traceDebug(LOG_SCOPE, "finalization.rejected", {
+                traceRequestControl(LOG_SCOPE, "finalization.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     expectedVersion: version,
                     currentVersion: updates.length,
@@ -177,7 +201,8 @@ export function createRequestSteeringInbox(params) {
                 return false;
             }
             sealed = true;
-            traceDebug(LOG_SCOPE, "finalization.sealed", {
+            traceRequestControl(LOG_SCOPE, "finalization.sealed", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 version,
             });

package/dist/src/runtime/request/worker-capability-composition.d.ts

@@ -1,3 +1,4 @@
+import type { RuntimeModelPluginConfig } from "../config/model-plugin-config.js";
 import type { RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
@@ -10,6 +11,7 @@ type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
     requestWorkingDirectory?: string;
     filesystemScope?: RuntimeFilesystemScope;
     executionPolicyAuthority?: ExecutionPolicyAuthoritySnapshot;
+    modelPlugins?: RuntimeModelPluginConfig;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;
     toolRegistryOverride?: ToolRegistry;

package/dist/src/runtime/request/worker-capability-composition.js

@@ -16,6 +16,7 @@ export function createRequestWorkerCapabilityProvider(params) {
             request: params.request,
             requestWorkingDirectory: params.requestWorkingDirectory,
             toolPermissionMode: params.request.toolPermissionMode,
+            ...(params.modelPlugins ? { modelPlugins: params.modelPlugins } : {}),
             ...(params.requestAttachments
                 ? { requestAttachments: params.requestAttachments }
                 : {}),
@@ -41,7 +42,9 @@ export function createRequestWorkerCapabilityProvider(params) {
     const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
-        ...(params.request.toolResources ? { toolResources: params.request.toolResources } : {}),
+        ...(params.request.toolResources
+            ? { toolResources: params.request.toolResources }
+            : {}),
         sessionId: params.request.sessionId,
         requestContext: Object.freeze({
             agentMode: params.request.agentMode,

package/dist/src/runtime/scheduler/journal-index-state.d.ts

@@ -23,10 +23,10 @@ export declare function encodeJournalIndexState(state: JournalIndexState, genera
     runs: {
         file: string;
         id: string;
-        environmentId: string;
         status: import("./contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips";
         jobId: string;
         scheduledAt: string;
+        environmentId: string;
         jobRevision: number;
         target?: SchedulerStoredRun["target"];
         sessionId?: string;

package/dist/src/runtime/steps/execution-agent/capability-result-context.d.ts

@@ -0,0 +1,6 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { RoleCallLedgerHead, RoleCapabilityExecution } from "../../orchestration/role-calls/index.js";
+export declare const EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND: "runtime_execution_capability_result_v1";
+export declare const EXECUTION_CAPABILITY_TOOL_NAME: "runtime_capability";
+/** One exact native result representation for active input and saved-source compatibility. */
+export declare function buildExecutionCapabilityResultMessage(head: RoleCallLedgerHead, execution: RoleCapabilityExecution): ChatMessage;

package/dist/src/runtime/steps/execution-agent/capability-result-context.js

@@ -0,0 +1,29 @@
+import { projectCanonicalRequestToolResult } from "../../context/canonical-capability-result.js";
+export const EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND = "runtime_execution_capability_result_v1";
+export const EXECUTION_CAPABILITY_TOOL_NAME = "runtime_capability";
+/** One exact native result representation for active input and saved-source compatibility. */
+export function buildExecutionCapabilityResultMessage(head, execution) {
+    if (execution.status !== "settled" || execution.exactResult === undefined) {
+        throw new Error("execution_agent_continuation_result_invalid");
+    }
+    const canonical = projectCanonicalRequestToolResult(head, execution);
+    return Object.freeze({
+        role: "tool",
+        content: JSON.stringify({
+            kind: EXECUTION_CAPABILITY_RESULT_MESSAGE_KIND,
+            authority: "canonical_role_call_ledger",
+            presenceEffect: "runtime_result_only_not_user_intent",
+            invocationAttempt: execution.invocationAttempt,
+            result: {
+                executionId: execution.executionId,
+                capabilityId: execution.capabilityId,
+                outcome: canonical.outcome,
+                observedEffect: canonical.observedEffect,
+                summary: canonical.summary,
+                adapterResult: execution.exactResult,
+            },
+        }),
+        toolCallId: execution.executionId,
+        toolName: EXECUTION_CAPABILITY_TOOL_NAME,
+    });
+}