@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/request/super-failure-message.js

@@ -0,0 +1,40 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { ROLE_CALL_RESPONSE_MAX_LENGTH } from "../orchestration/role-calls/index.js";
+import { projectOutputLimitCause } from "../steps/degraded-finalization/output-limit-cause.js";
+import { boundedSuperFailureCode, createSuperFailureFallback, } from "../steps/degraded-finalization/super.js";
+/** Presentation uses trusted request services only, never a failed role ledger. */
+export async function composeSuperFailureMessage(params) {
+    const input = {
+        problem: {
+            stage: "request_failure",
+            code: boundedSuperFailureCode(params.error),
+            ...projectOutputLimitCause(params.error),
+        },
+        progress: null,
+    };
+    const version = params.steering.snapshot().version;
+    const explanation = params.finalization
+        ? await params.finalization.explain({
+            error: params.error,
+            input,
+            maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
+            steeringVersion: version,
+        })
+        : createSuperFailureFallback(input, version);
+    const currentVersion = params.steering.snapshot().version;
+    const output = currentVersion === explanation.steeringVersion
+        ? explanation.output
+        : createSuperFailureFallback(input, currentVersion).output;
+    await params.steering.close();
+    traceDebug("runtime.request", "super.failure_message_prepared", {
+        requestId: params.requestId,
+        primaryCode: input.problem.code,
+        secondaryCode: explanation.secondaryCode,
+        source: currentVersion === explanation.steeringVersion
+            ? explanation.source
+            : "runtime_fallback",
+        route: "request_failure",
+        steeringVersion: currentVersion,
+    });
+    return { content: output, grounding: "conversation" };
+}

package/dist/src/runtime/request/super-payload-context-failure.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerCapabilityPayloadModelRequest } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { RequestContextCompactionStore } from "../context/semantic-compaction/store.js";
+type PayloadRequest = Readonly<{
+    requestId: string;
+    prompt: string;
+    abortSignal: AbortSignal;
+    contextCompactionStore?: RequestContextCompactionStore;
+}>;
+/** Preserve normal failed-capability settlement; never create a role commit here. */
+export declare function quarantineOwnedSuperPayloadCheckpoint(request: PayloadRequest, input: WorkerCapabilityPayloadModelRequest, error: unknown): void;
+export {};

package/dist/src/runtime/request/super-payload-context-failure.js

@@ -0,0 +1,55 @@
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { validateRoleCallCandidate } from "../orchestration/role-calls/reducer.js";
+import { quarantineProvenOwnedSuperCheckpoint } from "./super-checkpoint-quarantine.js";
+import { traceDebug } from "../observability/debug-logger.js";
+/** Preserve normal failed-capability settlement; never create a role commit here. */
+export function quarantineOwnedSuperPayloadCheckpoint(request, input, error) {
+    if (request.abortSignal.aborted || !(error instanceof SuperContextFailure))
+        return;
+    const sidecar = input.superWorkerCompaction;
+    if (!sidecar || !request.contextCompactionStore)
+        return;
+    const head = sidecar.head;
+    if (!hasSuperContextContract(head.policy.authority, "delegated.worker"))
+        return;
+    const call = head.state.calls.find((candidate) => candidate.callId === sidecar.callId);
+    if (!call || call.roleId !== "worker" || call.status !== "active")
+        return;
+    if (head.state.phase !== "running" || head.state.activeCallId !== call.callId)
+        return;
+    if (head.state.requestId !== request.requestId ||
+        sidecar.requestId !== request.requestId)
+        return;
+    if (sidecar.sourceRevision !== head.revision ||
+        sidecar.invocationAttempt !== call.activationCount)
+        return;
+    const binding = error.binding;
+    if (binding.requestId !== request.requestId || binding.callId !== call.callId)
+        return;
+    if (binding.parentCallId !== call.parentCallId ||
+        binding.contractId !== "delegated.worker")
+        return;
+    if (binding.sourceRevision !== head.revision ||
+        binding.invocationAttempt !== call.activationCount)
+        return;
+    if (binding.scopeId !== `worker:${call.callId}:request-tool-results` ||
+        binding.modelStep !== input.modelStep)
+        return;
+    if (validateRoleCallCandidate({ state: head.state, policy: head.policy }).length)
+        return;
+    const validation = quarantineProvenOwnedSuperCheckpoint({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        head,
+        store: request.contextCompactionStore,
+        scopeId: binding.scopeId,
+    });
+    if (validation)
+        traceDebug("runtime.context.compaction", "payload_checkpoint.quarantined", {
+            ...binding,
+            code: error.code,
+            validationCode: validation,
+            route: "settle_then_fresh_activation",
+        });
+}

package/dist/src/runtime/request/super-root-failure-finalization.d.ts

@@ -0,0 +1,23 @@
+import type { ModelOutputFailure } from "../model/invalid-output-failure.js";
+import { type RoleCallLedger, type RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+import type { RequestRunnerResult } from "./result.js";
+import type { SupervisorRootFailureStage } from "./supervisor-root-execution-diagnostics.js";
+/** A valid root transaction is separate from the outer failed request lifecycle. */
+export declare function finalizeSuperRootFailure(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    expectedHead: RoleCallLedgerHead | undefined;
+    failureStage: SupervisorRootFailureStage;
+    steeringVersion: number;
+    publishDeferredTitle?: (() => Promise<void>) | undefined;
+    error: unknown;
+    failure?: (ModelOutputFailure & Readonly<{
+        steeringVersion?: number;
+    }>) | undefined;
+}): Promise<Readonly<{
+    kind: "continue";
+}> | Readonly<{
+    kind: "complete";
+    result: RequestRunnerResult;
+}> | undefined>;

package/dist/src/runtime/request/super-root-failure-finalization.js

@@ -0,0 +1,112 @@
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
+import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
+import { boundedSuperFailureCode, fitsSuperFailureResponse, } from "../steps/degraded-finalization/super.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { projectInvalidOutputProgress } from "./root-invalid-output-progress.js";
+import { commitSupervisorResponse } from "./root-response-commit.js";
+import { hasSafeSuperContextFailureReturn, hasSafeSuperContextState, } from "./super-context-failure-integrity.js";
+/** A valid root transaction is separate from the outer failed request lifecycle. */
+export async function finalizeSuperRootFailure(params) {
+    const finalization = params.request.superFailureFinalization;
+    if (!finalization)
+        return undefined;
+    params.request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(params.request.requestSteering);
+    const steeringVersion = params.failure?.steeringVersion ?? params.steeringVersion;
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    finalization.remember(params.error, params.failure?.validationStage ?? params.failureStage);
+    const head = params.ledger.current();
+    const root = head.state.calls.find(({ callId }) => callId === head.state.rootCallId);
+    if (!canCommitSuperFailure(head, params.expectedHead, root))
+        return undefined;
+    if (!isOwnedSuperRootFailure(params, head, root))
+        return undefined;
+    const explanation = await finalization.explain({
+        error: params.error,
+        input: {
+            problem: {
+                stage: params.failure?.validationStage ?? params.failureStage,
+                code: boundedSuperFailureCode(params.error),
+            },
+            progress: projectInvalidOutputProgress(head),
+        },
+        maxResponseChars: head.policy.limits.maxResponseChars,
+        steeringVersion,
+    });
+    params.request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    if (params.ledger.current() !== head)
+        throw params.error;
+    if (!isOwnedSuperRootFailure(params, head, root))
+        throw params.error;
+    if (!fitsSuperFailureResponse(explanation.output, head.policy.limits.maxResponseChars)) {
+        traceDebug("runtime.request", "super.failure_response_limit_invalid", {
+            requestId: params.request.requestId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            secondaryCode: "degraded_finalization_response_limit_invalid",
+        });
+        throw params.error;
+    }
+    if (!steering.seal(steeringVersion))
+        return { kind: "continue" };
+    try {
+        await params.publishDeferredTitle?.();
+        params.request.abortSignal.throwIfAborted();
+        if (params.ledger.current() !== head)
+            throw params.error;
+        if (!isOwnedSuperRootFailure(params, head, root))
+            throw params.error;
+        const output = await commitSupervisorResponse({
+            transactions: resolveRoleCallTransactions(params.ledger),
+            expectedHead: head,
+            callId: root.callId,
+            response: explanation.output,
+        });
+        traceDebug("runtime.request", "super.failure_finalized", {
+            requestId: params.request.requestId,
+            callId: root.callId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            source: explanation.source,
+            disposition: "blocked",
+        });
+        return { kind: "complete", result: { output, disposition: "blocked" } };
+    }
+    catch (error) {
+        params.request.abortSignal.throwIfAborted();
+        traceDebug("runtime.request", "super.failure_commit_failed", {
+            requestId: params.request.requestId,
+            primaryCode: boundedSuperFailureCode(params.error),
+            secondaryCode: boundedSuperFailureCode(error),
+        });
+        throw params.error;
+    }
+}
+function canCommitSuperFailure(head, expectedHead, root) {
+    if (head !== expectedHead)
+        return false;
+    if (!root || root.roleId !== RUNTIME_ROOT_ROLE_ID)
+        return false;
+    if (root.status !== "active")
+        return false;
+    if (head.state.activeCallId !== root.callId)
+        return false;
+    return head.state.phase === "running";
+}
+function isOwnedSuperRootFailure(params, head, root) {
+    const state = {
+        request: params.request,
+        ledger: params.ledger,
+        expectedHead: head,
+        call: root,
+        contractId: params.request.executionPolicy.rootContract.contractId,
+    };
+    if (params.failure)
+        return hasSafeSuperContextState(state);
+    if (!(params.error instanceof SuperContextFailure))
+        return false;
+    return hasSafeSuperContextFailureReturn({ ...state, error: params.error });
+}

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

@@ -1,3 +1,4 @@
+import type { RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
@@ -7,6 +8,7 @@ import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView }
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
     request: TRequest;
     requestWorkingDirectory?: string;
+    filesystemScope?: RuntimeFilesystemScope;
     executionPolicyAuthority?: ExecutionPolicyAuthoritySnapshot;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;

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

@@ -57,10 +57,13 @@ export function createRequestWorkerCapabilityProvider(params) {
                 toolApprovalController: params.request.toolApprovalController,
             }
             : {}),
-        payloadAuthor: createRequestWorkerCapabilityPayloadAuthor(params.request, params.executionPolicyAuthority?.capabilityAuthorities),
+        payloadAuthor: createRequestWorkerCapabilityPayloadAuthor(params.request, params.executionPolicyAuthority?.capabilityAuthorities, params.filesystemScope),
         loadActionSkillContext: (toolName) => getRequestSkillProvider().getActionContext(toolName),
         nextApprovalId: () => `approval:${randomUUID()}`,
         onEvent: params.request.onEvent,
+        ...(params.request.effectPersistence
+            ? { effectPersistence: params.request.effectPersistence }
+            : {}),
     });
     return Object.freeze({
         ...provider,

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

@@ -1,7 +1,8 @@
+import { type RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
 import { type WorkerCapabilityPayloadAuthor } from "../orchestration/worker-capabilities/index.js";
 import type { ExecutionPolicyCapabilityAuthority } from "../orchestration/role-calls/index.js";
 import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "./contracts.js";
 type RequestWorkerCapabilityPayloadContext = BoundRequestModelInvocationContext & Pick<RequestExecutionSeed, "prompt" | "historyMessages" | "onEvent" | "contextCompactionStore">;
 /** Binds the neutral payload-author port to one request's model boundary. */
-export declare function createRequestWorkerCapabilityPayloadAuthor(request: RequestWorkerCapabilityPayloadContext, capabilityAuthorities?: readonly ExecutionPolicyCapabilityAuthority[]): WorkerCapabilityPayloadAuthor;
+export declare function createRequestWorkerCapabilityPayloadAuthor(request: RequestWorkerCapabilityPayloadContext, capabilityAuthorities?: readonly ExecutionPolicyCapabilityAuthority[], filesystemScope?: RuntimeFilesystemScope): WorkerCapabilityPayloadAuthor;
 export {};

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

@@ -1,38 +1,68 @@
+import { buildRuntimeFilesystemScopeMessage, } from "../context/runtime-filesystem-scope.js";
+import { quarantineOwnedSuperPayloadCheckpoint } from "./super-payload-context-failure.js";
+import { assertSuperWorkerCompactionSidecarBinding } from "../context/super-worker-compaction-sidecar.js";
 import { projectRequestContext } from "../context/request-context.js";
 import { createModelStepCompactionController } from "../context/model-step-compaction.js";
-import { projectCurrentRequestToolResults } from "../context/request-tool-results.js";
-import { createSemanticCompactionSha256Fingerprint, } from "../context/semantic-compaction/index.js";
 import { buildRequestSourceMessage, projectRequestSource, } from "../context/request-source.js";
 import { resolveModelContextBudget } from "../model/model-context-budget.js";
-import { validateJsonSchemaValue } from "../model/json-schema-value.js";
+import { normalizePayloadBody } from "../orchestration/worker-capabilities/payload-body-normalization.js";
 import { invokeRepairableRawModelStep, RawModelValidationError, } from "../model/invoke-raw-step.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { createWorkerCapabilityPayloadAuthor, workerCapabilityContextCompactionScopeId, WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS, WorkerCapabilityPayloadBudgetExceededError, WorkerCapabilityPayloadValidationError, } from "../orchestration/worker-capabilities/index.js";
 import { buildWorkerCapabilityPayloadRepairHint } from "./worker-capability-payload-prompts.js";
+import { projectExecutionPayloadCompactedEvidence } from "./execution-payload-compacted-evidence.js";
 const PAYLOAD_TARGET_CONTENT_MESSAGE_KIND = "runtime_payload_target_content_v1";
 const PAYLOAD_RELATED_ARTIFACT_CONTENT_MESSAGE_KIND = "runtime_payload_related_artifact_content_v1";
 const WORKER_CAPABILITY_PAYLOAD_MAX_REPAIR_ATTEMPTS = 2;
 /** Binds the neutral payload-author port to one request's model boundary. */
-export function createRequestWorkerCapabilityPayloadAuthor(request, capabilityAuthorities) {
-    return createWorkerCapabilityPayloadAuthor({
-        requestId: request.requestId,
-        abortSignal: request.abortSignal,
-        ...(capabilityAuthorities ? { capabilityAuthorities } : {}),
-        model: Object.freeze({
-            invoke: (input) => invokePayloadModel(request, input),
-        }),
+export function createRequestWorkerCapabilityPayloadAuthor(request, capabilityAuthorities, filesystemScope) {
+    const frozenAuthorities = capabilityAuthorities
+        ? Object.freeze([...capabilityAuthorities])
+        : undefined;
+    return Object.freeze({
+        author: (authorInput) => {
+            return createWorkerCapabilityPayloadAuthor({
+                requestId: request.requestId,
+                abortSignal: request.abortSignal,
+                ...(frozenAuthorities
+                    ? { capabilityAuthorities: frozenAuthorities }
+                    : {}),
+                model: Object.freeze({
+                    invoke: (input) => invokePayloadModel(request, input, buildRuntimeFilesystemScopeMessage({
+                        scope: filesystemScope,
+                        workingDirectory: authorInput.call.workingDirectory,
+                        capabilities: [authorInput.descriptor],
+                    })),
+                }),
+            }).author(authorInput);
+        },
     });
 }
-async function invokePayloadModel(request, input) {
+async function invokePayloadModel(request, input, filesystemMessage) {
     const compactionOptions = payloadCompactionOptions(input);
+    if (input.superWorkerCompaction)
+        assertSuperWorkerCompactionSidecarBinding(input.superWorkerCompaction, {
+            requestId: request.requestId,
+            callId: payloadContextCallId(input.context),
+        });
     try {
+        const projection = payloadMessages(request, input, filesystemMessage);
         return await invokeRepairableRawModelStep({
             request,
             modelStep: input.modelStep,
-            messages: payloadMessages(request, input),
+            messages: projection.messages,
             contextCompaction: createModelStepCompactionController(request, {
+                consumer: input.modelStep,
+                hasVerifiedCompactedEvidence: projection.hasVerifiedCompactedEvidence,
                 call: payloadCompactionCall(request.prompt, input.context),
-                sourceRevision: payloadCompactionSourceRevision(input.context),
+                sourceRevision: input.superWorkerCompaction?.sourceRevision ??
+                    payloadCompactionSourceRevision(input.context),
+                ...(input.superWorkerCompaction
+                    ? {
+                        superWorkerCompaction: input.superWorkerCompaction,
+                        requireSuperWorkerSources: true,
+                    }
+                    : {}),
                 allowedConsumers: compactionOptions.allowedConsumers,
                 scopeId: compactionOptions.scopeId,
                 ...(compactionOptions.resultSourceOverrides
@@ -49,6 +79,7 @@ async function invokePayloadModel(request, input) {
         });
     }
     catch (error) {
+        quarantineOwnedSuperPayloadCheckpoint(request, input, error);
         const code = payloadValidationCode(error);
         if (code) {
             throw new WorkerCapabilityPayloadValidationError(code);
@@ -62,24 +93,11 @@ async function invokePayloadModel(request, input) {
     }
 }
 function validatePayloadModelOutput(text, minBytes, maxBytes, responseFormat) {
-    let normalized = text;
-    if (responseFormat) {
-        let parsed;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch {
-            return invalidStructuredPayload("output", "Return one valid JSON value matching the frozen response format.");
-        }
-        if (responseFormat !== "json") {
-            const schemaIssue = validateJsonSchemaValue(responseFormat, parsed);
-            if (schemaIssue) {
-                return invalidStructuredPayload(schemaIssue.path, schemaIssue.message);
-            }
-        }
-        normalized = JSON.stringify(parsed);
+    const normalized = normalizePayloadBody(text, responseFormat);
+    if (!normalized.ok) {
+        return invalidStructuredPayload(normalized.issue.path, normalized.issue.message);
     }
-    const payloadBytes = Buffer.byteLength(normalized, "utf8");
+    const payloadBytes = Buffer.byteLength(normalized.body, "utf8");
     if (payloadBytes >= minBytes && payloadBytes <= maxBytes) {
         return Object.freeze({ ok: true, value: text });
     }
@@ -127,7 +145,7 @@ function payloadValidationCode(error) {
         ? code
         : undefined;
 }
-function payloadMessages(request, input) {
+function payloadMessages(request, input, filesystemMessage) {
     const callId = payloadContextCallId(input.context);
     const budget = resolveModelContextBudget({
         runnerConfig: request.runnerConfig,
@@ -147,12 +165,13 @@ function payloadMessages(request, input) {
             historyMessages: request.historyMessages,
         })
         : undefined;
-    const projectedContext = projectPayloadContext(input.context);
+    const projectedContext = projectPayloadContext(input.context, request);
     traceDebug("runtime.worker_capability_payload_context", "projected", {
         requestId: request.requestId,
         modelStep: input.modelStep,
         callId,
         contextScope: projectedContext.contextScope,
+        reusedCompactedSourceCount: projectedContext.reusedCompactedSourceCount,
         settledCapabilityResultCount: input.context.settledCapabilityResults.length,
         ...projectedContext.settledResultDiagnostics,
         relatedArtifactContextCount: projectedContext.relatedArtifactMessages.length,
@@ -160,12 +179,14 @@ function payloadMessages(request, input) {
         hasTargetContext: input.context.targetContext !== undefined,
         requestSourceProjection: input.requestSourceProjection,
     });
+    const canonicalContext = `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`;
     try {
-        return projectRequestContext({
+        const messages = projectRequestContext({
             instructions: input.instructions,
             historyMessages: [],
-            prompt: `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`,
+            prompt: canonicalContext,
             referenceMessages: [
+                ...(filesystemMessage ? [filesystemMessage] : []),
                 ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
@@ -181,6 +202,14 @@ function payloadMessages(request, input) {
             onEvent: request.onEvent,
             deferCompactionFailure: true,
         }).messages;
+        return Object.freeze({
+            messages,
+            hasVerifiedCompactedEvidence(candidateMessages) {
+                if (projectedContext.reusedCompactedSourceCount === 0)
+                    return false;
+                return candidateMessages.some((message) => message.role === "user" && message.content === canonicalContext);
+            },
+        });
     }
     catch (error) {
         if (error instanceof Error &&
@@ -221,7 +250,9 @@ function payloadCompactionOptions(input) {
         return Object.freeze({
             allowedConsumers: WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS,
             scopeId: workerCapabilityContextCompactionScopeId(input.context.worker.callId),
-            resultSourceOverrides: createWorkerPayloadResultSources(input.context),
+            ...(input.superWorkerCompaction
+                ? { resultSourceOverrides: input.superWorkerCompaction.sources }
+                : {}),
         });
     }
     return Object.freeze({
@@ -234,17 +265,7 @@ function payloadCompactionOptions(input) {
         ].join(":"),
     });
 }
-function createWorkerPayloadResultSources(context) {
-    return Object.freeze(projectCurrentRequestToolResults(context.settledCapabilityResults).map((result) => {
-        const content = JSON.stringify(result);
-        return Object.freeze({
-            sourceRef: result.executionId,
-            sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
-            content,
-        });
-    }));
-}
-function projectPayloadContext(context) {
+function projectPayloadContext(context, request) {
     const contextScope = context.contextScope;
     const targetProjection = context.targetContext
         ? projectTargetContext(context.targetContext)
@@ -253,13 +274,17 @@ function projectPayloadContext(context) {
         ? []
         : (context.relatedArtifactContexts ?? []).map((artifact, index) => projectRelatedArtifactContext(artifact, index));
     const settledResultProjection = projectSettledResultsForPayload(context, contextScope);
+    const compactedEvidence = projectExecutionPayloadCompactedEvidence(request, context, settledResultProjection.results);
     const baseMetadata = { ...context };
     delete baseMetadata.targetContext;
     delete baseMetadata.relatedArtifactContexts;
     return Object.freeze({
         metadata: Object.freeze({
             ...baseMetadata,
-            settledCapabilityResults: settledResultProjection.results,
+            settledCapabilityResults: compactedEvidence.results,
+            ...(compactedEvidence.evidence
+                ? { compactedSourceEvidence: compactedEvidence.evidence }
+                : {}),
             ...(targetProjection ? { targetContext: targetProjection.metadata } : {}),
             ...(relatedArtifactProjections.length > 0
                 ? {
@@ -273,6 +298,7 @@ function projectPayloadContext(context) {
             : {}),
         contextScope,
         settledResultDiagnostics: settledResultProjection.diagnostics,
+        reusedCompactedSourceCount: compactedEvidence.evidence?.sources.length ?? 0,
     });
 }
 /**

package/dist/src/runtime/runtime-environment.d.ts

@@ -1,4 +1,5 @@
 import { SessionRequestAdmission } from "./request/session-admission.js";
+import { type AutomationService } from "./automations/service.js";
 import type { EventSinkFactory, RuntimeConfig } from "./ports.js";
 import type { RuntimeApplicationOverrides, RuntimeEnvironmentServices } from "./composition.js";
 export declare function createRuntimeEnvironment(config: RuntimeConfig, overrides?: RuntimeApplicationOverrides): {
@@ -13,7 +14,8 @@ export declare function createRuntimeEnvironment(config: RuntimeConfig, override
         sessionMemoryCompactor: import("./context/session-memory/contracts.js").SessionMemoryCompactor;
         longTermMemory: import("./index.js").LongTermMemoryService;
         passiveLearning?: import("./passive-learning/contracts.js").PassiveLearningService;
-        scheduler?: import("./index.js").SchedulerService;
+        automations?: AutomationService;
+        scheduler?: import("./scheduler/contracts.js").SchedulerService;
         startScheduler?: () => Promise<void>;
         stopScheduler?: () => Promise<void>;
         requestAdmission?: SessionRequestAdmission;