@abot-ai/runtime 1.1.0 → 1.3.0

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

@@ -3,6 +3,7 @@ import { removeEmptyLockTree, removeObservedOwner } from "./cleanup.js";
 import { fileSystemErrorCode, INCOMPLETE_LOCK_GRACE_MS, LOCK_ACQUIRE_TIMEOUT_MS, LOCK_RETRY_DELAY_MS, ownerFileName, } from "./contracts.js";
 import { installLockDirectory } from "./install.js";
 import { readLockSnapshot } from "./snapshot.js";
+import { removeObservedOwnerSynchronously } from "./synchronous-release.js";
 export async function acquireFileLock(lockPath, options) {
     const waitMs = options.waitMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
     const retryDelayMs = options.retryDelayMs ?? LOCK_RETRY_DELAY_MS;
@@ -12,7 +13,7 @@ export async function acquireFileLock(lockPath, options) {
         const token = randomUUID();
         try {
             await installLockDirectory(lockPath, token);
-            return createRelease(lockPath, token);
+            return createRelease(lockPath, token, options.releaseMode);
         }
         catch (error) {
             if (!isLockContention(error))
@@ -27,15 +28,23 @@ export async function acquireFileLock(lockPath, options) {
         }
     }
 }
-function createRelease(lockPath, token) {
+function createRelease(lockPath, token, releaseMode) {
     let released = false;
     return async () => {
         if (released)
             return;
+        if (requiresSynchronousRelease(releaseMode)) {
+            removeObservedOwnerSynchronously(lockPath, ownerFileName(token));
+            released = true;
+            return;
+        }
         await removeObservedOwner(lockPath, ownerFileName(token));
         released = true;
     };
 }
+function requiresSynchronousRelease(mode) {
+    return mode === "synchronous";
+}
 async function removeAbandonedLock(lockPath, processIsAlive) {
     const snapshot = await readLockSnapshot(lockPath);
     if (!snapshot)

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

@@ -8,6 +8,8 @@ export type FileLockOptions = Readonly<{
     waitMs?: number;
     retryDelayMs?: number;
     processIsAlive?: (pid: number) => boolean;
+    /** Long-lived host leases must finish physical cleanup before process.exit. */
+    releaseMode?: "asynchronous" | "synchronous";
 }>;
 export type LockRecord = Readonly<{
     pid: number;

package/dist/src/runtime/adapters/long-term-memory/file-lock/synchronous-release.d.ts

@@ -0,0 +1,2 @@
+/** Keep token removal and directory cleanup indivisible by JavaScript exit. */
+export declare function removeObservedOwnerSynchronously(lockPath: string, observedOwnerFileName: string): boolean;

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

@@ -0,0 +1,40 @@
+import { rmdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { fileSystemErrorCode, LEASE_DIRECTORY_NAME } from "./contracts.js";
+/** Keep token removal and directory cleanup indivisible by JavaScript exit. */
+export function removeObservedOwnerSynchronously(lockPath, observedOwnerFileName) {
+    try {
+        unlinkSync(join(lockPath, LEASE_DIRECTORY_NAME, observedOwnerFileName));
+    }
+    catch (error) {
+        if (fileSystemErrorCode(error) === "ENOENT")
+            return false;
+        throw error;
+    }
+    if (!removeReleasedDirectory(join(lockPath, LEASE_DIRECTORY_NAME)))
+        return false;
+    return removeReleasedDirectory(lockPath);
+}
+function removeReleasedDirectory(path) {
+    try {
+        rmdirSync(path);
+        return true;
+    }
+    catch (error) {
+        if (fileSystemErrorCode(error) === "ENOENT")
+            return true;
+        if (hasReplacementDirectoryContent(error))
+            return false;
+        throw error;
+    }
+}
+function hasReplacementDirectoryContent(error) {
+    switch (fileSystemErrorCode(error)) {
+        case "EEXIST":
+        case "ENOTEMPTY":
+        case "ENOTDIR":
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/approval.d.ts

@@ -1,7 +1,10 @@
 import type { ToolCall } from "../../../../capabilities/tool-types.js";
+import { type ToolEventExecutorIdentity } from "../shared/event-metadata.js";
 import type { ToolApprovalController, ToolPermissionMode } from "../../../ports.js";
 import type { RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
 export declare function requestNormalInvocationApproval(params: {
+    executionId?: string;
+    executorIdentity?: ToolEventExecutorIdentity;
     requestId: string;
     abortSignal: AbortSignal;
     toolPermissionMode: ToolPermissionMode;

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/approval.js

@@ -1,3 +1,4 @@
+import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
 export async function requestNormalInvocationApproval(params) {
     if (!params.force && params.toolPermissionMode !== "ask") {
@@ -5,6 +6,8 @@ export async function requestNormalInvocationApproval(params) {
     }
     const approvalId = params.nextApprovalId();
     params.onEvent?.("tool.approval.required", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         approvalId,
         tool: params.call.tool,
         ...(params.eventMeta ? { meta: params.eventMeta } : {}),
@@ -12,6 +15,8 @@ export async function requestNormalInvocationApproval(params) {
     if (!params.toolApprovalController) {
         const message = "Tool approval is required, but no approval controller is configured.";
         params.onEvent?.("tool.approval.rejected", {
+            ...buildToolExecutorEventMetadata(params.executorIdentity),
+            ...(params.executionId ? { executionId: params.executionId } : {}),
             approvalId,
             tool: params.call.tool,
             reason: message,
@@ -29,6 +34,8 @@ export async function requestNormalInvocationApproval(params) {
     }, { abortSignal: params.abortSignal });
     if (decision.approved) {
         params.onEvent?.("tool.approval.granted", {
+            ...buildToolExecutorEventMetadata(params.executorIdentity),
+            ...(params.executionId ? { executionId: params.executionId } : {}),
             approvalId,
             tool: params.call.tool,
         });
@@ -36,6 +43,8 @@ export async function requestNormalInvocationApproval(params) {
     }
     const message = decision.reason?.trim() || "Tool execution was rejected.";
     params.onEvent?.("tool.approval.rejected", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         approvalId,
         tool: params.call.tool,
         reason: message,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/rejection-event.d.ts

@@ -0,0 +1,13 @@
+import type { BoundOperation, RegisteredToolNormalInvocationExecutor, RegisteredToolNormalInvocationExecutorParams, RegisteredToolPreparedNormalInvocation } from "../shared/contracts.js";
+/** Projects source controls only; rejected calls are never prepared again. */
+export declare function prepareNormalInvocationRejectionEvent(params: {
+    operationByHandle: WeakMap<object, BoundOperation>;
+    input: Parameters<RegisteredToolNormalInvocationExecutor["prepareRejectionEvent"]>[0];
+    onEvent: RegisteredToolNormalInvocationExecutorParams["onEvent"];
+}): ReturnType<RegisteredToolNormalInvocationExecutor["prepareRejectionEvent"]>;
+/** Reports an admitted invocation rejected before the external tool ran. */
+export declare function createPreparedInvocationRejectionEmitter(params: {
+    tool: string;
+    eventMeta: Record<string, unknown> | undefined;
+    onEvent: RegisteredToolNormalInvocationExecutorParams["onEvent"];
+}): RegisteredToolPreparedNormalInvocation["emitRejection"];

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/rejection-event.js

@@ -0,0 +1,25 @@
+import { buildToolExecutorEventMetadata, buildToolIntentEventMetadata, } from "../shared/event-metadata.js";
+/** Projects source controls only; rejected calls are never prepared again. */
+export function prepareNormalInvocationRejectionEvent(params) {
+    const source = params.operationByHandle.get(params.input.handle);
+    if (!source)
+        return undefined;
+    return createPreparedInvocationRejectionEmitter({
+        tool: source.registration.toolName,
+        eventMeta: buildToolIntentEventMetadata({ tool: source.registration.toolName, params: params.input.controls }, params.input.intent, source.registration.definition),
+        onEvent: params.onEvent,
+    });
+}
+/** Reports an admitted invocation rejected before the external tool ran. */
+export function createPreparedInvocationRejectionEmitter(params) {
+    return ({ executionId, executorIdentity, errorCode }) => {
+        params.onEvent?.("tool.failed", {
+            ...buildToolExecutorEventMetadata(executorIdentity),
+            executionId,
+            tool: params.tool,
+            stage: "before_external_execution",
+            error: errorCode,
+            ...(params.eventMeta ? { meta: params.eventMeta } : {}),
+        });
+    };
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/run.js

@@ -1,8 +1,9 @@
 import { buildToolCompletedEventActions, buildToolCompletedEventMetadata, buildToolLifecycleEventCopy, } from "../../../../capabilities/tool-event-metadata.js";
 import { requestNormalInvocationApproval } from "./approval.js";
+import { createPreparedInvocationRejectionEmitter } from "./rejection-event.js";
 import { captureToolCall, materializeCall, resolveExactTargetOperation, validateCompleteCall, } from "./call-binding.js";
 import { createRegisteredToolActionFingerprint } from "../shared/action-fingerprint.js";
-import { buildToolIntentEventMetadata } from "../shared/event-metadata.js";
+import { buildToolExecutorEventMetadata, buildToolIntentEventMetadata, } from "../shared/event-metadata.js";
 import { prepareCompleteInvocationInput } from "../payload/input-preparation.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
 export async function executeNormalInvocation(params) {
@@ -59,7 +60,14 @@ export function prepareNormalInvocation(params) {
         status: "prepared",
         actionFingerprint,
         acceptedControls: preparedInput.controls,
-        execute: () => executePreparedNormalInvocation({
+        emitRejection: createPreparedInvocationRejectionEmitter({
+            tool: source.registration.toolName,
+            eventMeta,
+            onEvent: executor.onEvent,
+        }),
+        execute: (executionId, executorIdentity) => executePreparedNormalInvocation({
+            ...(executionId ? { executionId } : {}),
+            ...(executorIdentity ? { executorIdentity } : {}),
             executor,
             source,
             target: target.binding,
@@ -71,6 +79,10 @@ export function prepareNormalInvocation(params) {
 }
 async function executePreparedNormalInvocation(params) {
     const approval = await requestNormalInvocationApproval({
+        ...(params.executorIdentity
+            ? { executorIdentity: params.executorIdentity }
+            : {}),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         requestId: params.executor.requestId,
         abortSignal: params.executor.abortSignal,
         toolPermissionMode: params.executor.toolPermissionMode,
@@ -89,6 +101,8 @@ async function executePreparedNormalInvocation(params) {
     params.executor.abortSignal.throwIfAborted();
     const startedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, "started");
     params.executor.onEvent?.("tool.started", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         tool: params.call.tool,
         ...(params.input.intent
             ? { intent: params.input.intent, intentSource: "model" }
@@ -106,6 +120,8 @@ async function executePreparedNormalInvocation(params) {
     const completedMeta = buildToolCompletedEventMetadata(params.call, result, params.target.registration.definition);
     const completedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, result.ok ? "completed" : "failed");
     params.executor.onEvent?.("tool.completed", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         tool: params.source.registration.toolName,
         ok: result.ok,
         actions: completionActions,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/executor.js

@@ -4,6 +4,7 @@ import { projectRuntimePathBindings } from "./catalog/runtime-path-bindings.js";
 import { executeNormalInvocation, prepareNormalInvocation, } from "./execution/run.js";
 import { emitNormalInvocationPayloadLifecycle } from "./payload/lifecycle.js";
 import { prepareNormalInvocationPayloadLifecycle } from "./payload/lifecycle.js";
+import { prepareNormalInvocationRejectionEvent } from "./execution/rejection-event.js";
 /**
  * Captures one selected ToolRegistry snapshot and executes its ordinary
  * invocation contracts. Normalization may only resolve another operation from
@@ -36,6 +37,13 @@ export function createRegisteredToolNormalInvocationExecutor(params) {
     })));
     return Object.freeze({
         operations,
+        prepareRejectionEvent(input) {
+            return prepareNormalInvocationRejectionEvent({
+                operationByHandle,
+                input,
+                onEvent: params.onEvent,
+            });
+        },
         emitPayloadLifecycle(input) {
             return emitNormalInvocationPayloadLifecycle({
                 operationByHandle,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/payload/lifecycle.js

@@ -1,5 +1,5 @@
 import { materializeCall } from "../execution/call-binding.js";
-import { buildToolIntentEventMetadata } from "../shared/event-metadata.js";
+import { buildToolExecutorEventMetadata, buildToolIntentEventMetadata, } from "../shared/event-metadata.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
 import { validatePublicInput } from "./input-preparation.js";
 export function emitNormalInvocationPayloadLifecycle(params) {
@@ -35,8 +35,12 @@ export function prepareNormalInvocationPayloadLifecycle(params) {
     const event = materializePayloadLifecycleEvent(params.input, base);
     return Object.freeze({
         status: "prepared",
-        emit: () => {
-            params.onEvent?.(event.name, event.payload);
+        emit: (executionId, executorIdentity) => {
+            params.onEvent?.(event.name, {
+                ...event.payload,
+                ...buildToolExecutorEventMetadata(executorIdentity),
+                ...(executionId ? { executionId } : {}),
+            });
             return Object.freeze({ status: "emitted" });
         },
     });

package/dist/src/runtime/adapters/registered-tool-normal-invocations/shared/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { ToolEventExecutorIdentity } from "./event-metadata.js";
 import type { RegisteredToolNormalInvocation, ToolActionSummary, ToolExecutionResult, ToolExecutionSharedState, ToolNormalInvocationEffect, ToolNormalInvocationOperation } from "../../../../capabilities/tool-types.js";
 import type { ToolApprovalController, ToolPermissionMode, ToolRegistry } from "../../../ports.js";
 import type { RegisteredToolPayloadContextPlan, RegisteredToolStagedPayloadPlan } from "../../registered-tool-payload-plan.js";
@@ -37,7 +38,14 @@ export type RegisteredToolPreparedNormalInvocation = Readonly<{
     actionFingerprint: string;
     /** Exact validated non-payload controls accepted for this invocation. */
     acceptedControls: Readonly<Record<string, unknown>>;
-    execute(): Promise<RegisteredToolNormalInvocationResult>;
+    /** Client-only terminal event when admission is rejected before execution. */
+    emitRejection(input: Readonly<{
+        executionId: string;
+        executorIdentity: ToolEventExecutorIdentity;
+        errorCode: string;
+    }>): void;
+    /** Canonical execution identity for client lifecycle events only. */
+    execute(executionId?: string, executorIdentity?: ToolEventExecutorIdentity): Promise<RegisteredToolNormalInvocationResult>;
 }>;
 export type RegisteredToolNormalInvocationPreparation = RegisteredToolPreparedNormalInvocation | RegisteredToolNormalInvocationRejection;
 export type RegisteredToolNormalInvocationPayloadLifecyclePhase = "started" | "completed" | "failed";
@@ -46,13 +54,20 @@ export type RegisteredToolNormalInvocationPayloadLifecycleResult = Readonly<{
 }> | RegisteredToolNormalInvocationRejection;
 export type RegisteredToolPreparedNormalInvocationPayloadLifecycle = Readonly<{
     status: "prepared";
-    emit(): Readonly<{
+    /** Canonical execution identity for client lifecycle events only. */
+    emit(executionId?: string, executorIdentity?: ToolEventExecutorIdentity): Readonly<{
         status: "emitted";
     }>;
 }>;
 export type RegisteredToolNormalInvocationPayloadLifecyclePreparation = RegisteredToolPreparedNormalInvocationPayloadLifecycle | RegisteredToolNormalInvocationRejection;
 export type RegisteredToolNormalInvocationExecutor = Readonly<{
     operations: readonly RegisteredToolNormalInvocationProjection[];
+    /** Prepares client-only rejection reporting for a registered source handle. */
+    prepareRejectionEvent(input: Readonly<{
+        handle: RegisteredToolNormalInvocationHandle;
+        controls: Readonly<Record<string, unknown>>;
+        intent?: string;
+    }>): RegisteredToolPreparedNormalInvocation["emitRejection"] | undefined;
     /**
      * Emits the existing client payload lifecycle without exposing the bound
      * tool name or payload parameter to the profile that owns model context.

package/dist/src/runtime/adapters/registered-tool-normal-invocations/shared/event-metadata.d.ts

@@ -1,2 +1,11 @@
 import type { ToolCall, ToolDefinition } from "../../../../capabilities/tool-types.js";
 export declare function buildToolIntentEventMetadata(call: ToolCall, intent: string | undefined, definition?: ToolDefinition): Record<string, unknown> | undefined;
+/** Canonical caller identity used only to attribute client lifecycle events. */
+export type ToolEventExecutorIdentity = Readonly<{
+    callId: string;
+    roleId: string;
+}>;
+export declare function buildToolExecutorEventMetadata(identity: ToolEventExecutorIdentity | undefined): {
+    roleCallId: string;
+    executorRole: string;
+} | undefined;

package/dist/src/runtime/adapters/registered-tool-normal-invocations/shared/event-metadata.js

@@ -8,3 +8,11 @@ export function buildToolIntentEventMetadata(call, intent, definition) {
         intent,
     };
 }
+export function buildToolExecutorEventMetadata(identity) {
+    if (!identity)
+        return undefined;
+    return {
+        roleCallId: identity.callId,
+        executorRole: identity.roleId,
+    };
+}

package/dist/src/runtime/adapters/registered-tool-payload-plan.d.ts

@@ -1,6 +1,4 @@
 import type { ToolDefinition, ToolExecutionSharedState, ToolNormalInvocationInput, ToolNormalInvocationOperation, ToolPayloadChannelSpec, ToolPayloadChannelStageSpec } from "../../capabilities/tool-types.js";
-import { type WorkerCapabilityPayloadRelatedArtifactContext } from "../orchestration/worker-capabilities/payload-contracts.js";
-import type { WorkerSettledCapabilityResult } from "../orchestration/worker-capabilities/contracts.js";
 export type RegisteredToolPayloadStage = Readonly<{
     outputParam: string;
     instructions: string;
@@ -72,13 +70,6 @@ export declare function resolveRegisteredToolPayloadTargetContext(params: {
     sharedState: ToolExecutionSharedState;
     materializedParams?: Readonly<Record<string, string>>;
 }): Promise<RegisteredToolPayloadTargetContext | undefined>;
-export declare function resolveRegisteredToolPayloadRelatedArtifactContexts(params: {
-    contextScope?: ToolPayloadChannelSpec["contextScope"];
-    targetParam?: string;
-    controls: Readonly<Record<string, unknown>>;
-    sharedState: ToolExecutionSharedState;
-    settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
-}): Promise<readonly WorkerCapabilityPayloadRelatedArtifactContext[]>;
 export declare function materializeRegisteredToolPayloadStageResponseFormat(params: {
     stage: RegisteredToolPayloadStage;
     targetContext?: RegisteredToolPayloadTargetContext;

package/dist/src/runtime/adapters/registered-tool-payload-plan.js

@@ -1,7 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import { TOOL_PAYLOAD_STAGE_LITERAL_OUTPUT_MAX_BYTES } from "../../capabilities/tool-types.js";
 import { resolveRuntimeTargetPath } from "../capabilities/runtime-target-path.js";
-import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
 export function deriveRegisteredToolPayloadContextPlan(definition, operation) {
     const spec = definition.payloadChannelSpec;
     if (!operation.payload ||
@@ -227,72 +226,6 @@ export async function resolveRegisteredToolPayloadTargetContext(params) {
         content,
     });
 }
-export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
-    if (params.contextScope !== "target_with_artifacts") {
-        return Object.freeze([]);
-    }
-    const currentTarget = resolveCurrentTarget(params);
-    const resolvedTargets = new Set();
-    const artifacts = [];
-    let totalCharacters = 0;
-    for (const result of params.settledCapabilityResults) {
-        if (result.outcome !== "succeeded")
-            continue;
-        for (const reference of result.references ?? []) {
-            let resolvedTarget;
-            try {
-                resolvedTarget = resolveRuntimeTargetPath(reference.target, params.sharedState);
-            }
-            catch {
-                continue;
-            }
-            if (resolvedTarget === currentTarget ||
-                resolvedTargets.has(resolvedTarget)) {
-                continue;
-            }
-            resolvedTargets.add(resolvedTarget);
-            try {
-                const targetStat = await stat(resolvedTarget);
-                if (!targetStat.isFile())
-                    continue;
-                const content = await readFile(resolvedTarget, "utf8");
-                if (content.length + totalCharacters >
-                    WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS) {
-                    continue;
-                }
-                artifacts.push(Object.freeze({
-                    sourceExecutionId: result.executionId,
-                    targetPath: reference.target,
-                    presentation: "full",
-                    content,
-                }));
-                totalCharacters += content.length;
-                if (artifacts.length >=
-                    WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT) {
-                    return Object.freeze(artifacts);
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return Object.freeze(artifacts);
-}
-function resolveCurrentTarget(params) {
-    const rawTarget = params.targetParam
-        ? params.controls[params.targetParam]
-        : undefined;
-    if (typeof rawTarget !== "string" || rawTarget.trim().length === 0) {
-        return undefined;
-    }
-    try {
-        return resolveRuntimeTargetPath(rawTarget.trim(), params.sharedState);
-    }
-    catch {
-        return undefined;
-    }
-}
 function resolveBoundedTargetContext(params) {
     const stageIndex = params.plan.stages.indexOf(params.stage);
     const priorStages = params.plan.stages

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.d.ts

@@ -0,0 +1,13 @@
+import type { ToolExecutionSharedState, ToolPayloadChannelSpec } from "../../capabilities/tool-types.js";
+import type { WorkerCapabilityPayloadSourceProvenance, WorkerSettledCapabilityResult } from "../orchestration/worker-capabilities/contracts.js";
+import { type WorkerCapabilityPayloadRelatedArtifactContext } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { RoleCallFrame } from "../orchestration/role-calls/contracts.js";
+export declare function resolveRegisteredToolPayloadRelatedArtifactContexts(params: {
+    contextScope?: ToolPayloadChannelSpec["contextScope"];
+    targetParam?: string;
+    controls: Readonly<Record<string, unknown>>;
+    sharedState: ToolExecutionSharedState;
+    call: RoleCallFrame;
+    assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
+    settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
+}): Promise<readonly WorkerCapabilityPayloadRelatedArtifactContext[]>;

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.js

@@ -0,0 +1,84 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolveRuntimeTargetPath } from "../capabilities/runtime-target-path.js";
+import { projectWorkerCapabilityDependencyArtifactReceipts, } from "../orchestration/worker-capabilities/assignment-provenance.js";
+import { projectWorkerPayloadPlannerItemProvenance } from "../orchestration/worker-capabilities/payload-source-provenance.js";
+import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
+export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
+    if (params.contextScope !== "target_with_artifacts") {
+        return Object.freeze([]);
+    }
+    const dependencyReceipts = projectWorkerCapabilityDependencyArtifactReceipts(projectWorkerPayloadPlannerItemProvenance(params.assignmentProvenance, params.call), params.call);
+    const receipts = [
+        ...projectSameCallArtifactReceipts(params.settledCapabilityResults),
+        ...dependencyReceipts,
+    ];
+    return loadRelatedArtifactContexts(params, receipts);
+}
+function projectSameCallArtifactReceipts(results) {
+    return results.flatMap((result) => {
+        if (result.outcome !== "succeeded")
+            return [];
+        return (result.references ?? []).map((reference) => Object.freeze({
+            sourceExecutionId: result.executionId,
+            targetPath: reference.target,
+        }));
+    });
+}
+async function loadRelatedArtifactContexts(params, receipts) {
+    const currentTarget = resolveCurrentTarget(params);
+    const resolvedTargets = new Set();
+    const artifacts = [];
+    let totalCharacters = 0;
+    for (const receipt of receipts) {
+        let resolvedTarget;
+        try {
+            resolvedTarget = resolveRuntimeTargetPath(receipt.targetPath, params.sharedState);
+        }
+        catch {
+            continue;
+        }
+        if (resolvedTarget === currentTarget ||
+            resolvedTargets.has(resolvedTarget)) {
+            continue;
+        }
+        resolvedTargets.add(resolvedTarget);
+        try {
+            const targetStat = await stat(resolvedTarget);
+            if (!targetStat.isFile())
+                continue;
+            const content = await readFile(resolvedTarget, "utf8");
+            if (content.length + totalCharacters >
+                WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS) {
+                continue;
+            }
+            artifacts.push(Object.freeze({
+                sourceExecutionId: receipt.sourceExecutionId,
+                targetPath: receipt.targetPath,
+                presentation: "full",
+                content,
+            }));
+            totalCharacters += content.length;
+            if (artifacts.length >= WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT) {
+                return Object.freeze(artifacts);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return Object.freeze(artifacts);
+}
+function resolveCurrentTarget(params) {
+    const rawTarget = params.targetParam
+        ? params.controls[params.targetParam]
+        : undefined;
+    if (typeof rawTarget !== "string" || rawTarget.trim().length === 0) {
+        return undefined;
+    }
+    try {
+        return resolveRuntimeTargetPath(rawTarget.trim(), params.sharedState);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/catalog.js

@@ -112,6 +112,10 @@ function projectWorkerDescriptor(definition, operation, stagedPayloadPlan) {
             ? { requiresPayloadAuthoringObjective: true }
             : {}),
         catalogGroups,
+        routingCapability: definition.routingCapability,
+        ...(definition.developmentRoles
+            ? { developmentRoles: Object.freeze([...definition.developmentRoles]) }
+            : {}),
     });
 }
 function projectRuntimePathControlIds(definition, operation, controls) {

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/execution.js

@@ -113,6 +113,9 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
         sharedState: params.sharedState,
         ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
         call: input.call,
+        ...(input.assignmentProvenance
+            ? { assignmentProvenance: input.assignmentProvenance }
+            : {}),
         // The payload contract still names this correlation executionId. During
         // prepare it is deliberately non-canonical and never enters the ledger.
         executionId: input.preparationId,
@@ -163,6 +166,11 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
             selectedTargetReferences,
             rejectedExecution: canonicalRejection,
             payloadObservability,
+            emitRejection: params.executor.prepareRejectionEvent({
+                handle: params.projection.handle,
+                controls: effectiveControls,
+                intent: input.intent,
+            }),
             ...(preparedPayload.body === undefined
                 ? {}
                 : { payload: preparedPayload.body }),
@@ -180,6 +188,11 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
                 tracePreparedExecutionStarted(params, input, operationId, executionId);
                 const rejectedExecution = executionFreshnessRejection(input.executionFreshness);
                 if (rejectedExecution) {
+                    normalPreparation.emitRejection({
+                        executionId,
+                        executorIdentity: input.call,
+                        errorCode: rejectedExecution.sourceIssueCode,
+                    });
                     return completeRuntimeRejection({
                         params,
                         input,
@@ -189,7 +202,7 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
                         rejectedExecution,
                     });
                 }
-                const externalResult = await normalPreparation.execute();
+                const externalResult = await normalPreparation.execute(executionId, input.call);
                 const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null);
                 const observedResult = attachTargetReferences(observed.result, selectedTargetReferences);
                 traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, executionId, observedResult, externalResult.status, {
@@ -232,6 +245,11 @@ function preparedRuntimeRejection(input) {
             try {
                 input.payloadObservability.release(executionId);
                 tracePreparedExecutionStarted(input.params, input.input, input.operationId, executionId);
+                input.emitRejection?.({
+                    executionId,
+                    executorIdentity: input.input.call,
+                    errorCode: input.rejectedExecution.sourceIssueCode,
+                });
                 return completeRuntimeRejection({ ...input, executionId });
             }
             catch (error) {

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.d.ts

@@ -9,6 +9,7 @@ export declare function prepareOperationPayload(params: Readonly<{
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;