@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/capabilities/runtime-target-path.d.ts

@@ -2,6 +2,7 @@ import type { RuntimeToolPathErrorCode, RuntimeToolPathResolver, ToolExecutionSh
 export declare const RUNTIME_TOOL_PATH_ERROR_CODES: Readonly<{
     readonly REQUIRED: "runtime_tool_path_required";
     readonly NULL_BYTE: "runtime_tool_path_null_byte";
+    readonly NAMESPACE_INVALID: "runtime_tool_path_namespace_invalid";
     readonly LOCATION_REQUIRED: "runtime_tool_path_location_required";
     readonly ROOT_UNAVAILABLE: "runtime_tool_path_root_unavailable";
     readonly WORKSPACE_UNAVAILABLE: "runtime_tool_path_workspace_unavailable";

package/dist/src/runtime/capabilities/runtime-target-path.js

@@ -1,8 +1,10 @@
 import { lstatSync, realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, parse, posix, relative, resolve, sep, } from "node:path";
+import { isRuntimePathNamespaceCompatible, isRuntimePathWithinRoot, normalizeRuntimePathForScope, } from "./runtime-path-namespace.js";
 export const RUNTIME_TOOL_PATH_ERROR_CODES = Object.freeze({
     REQUIRED: "runtime_tool_path_required",
     NULL_BYTE: "runtime_tool_path_null_byte",
+    NAMESPACE_INVALID: "runtime_tool_path_namespace_invalid",
     LOCATION_REQUIRED: "runtime_tool_path_location_required",
     ROOT_UNAVAILABLE: "runtime_tool_path_root_unavailable",
     WORKSPACE_UNAVAILABLE: "runtime_tool_path_workspace_unavailable",
@@ -28,9 +30,10 @@ function configuredRoot(value) {
     const trimmed = value?.trim();
     return trimmed ? resolve(trimmed) : undefined;
 }
-function isWithinRoot(target, root) {
-    const rel = relative(root, target);
-    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`));
+function assertRuntimePathNamespace(value) {
+    if (!isRuntimePathNamespaceCompatible(value)) {
+        throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.NAMESPACE_INVALID);
+    }
 }
 /**
  * Qualifies one manifest-owned operation target against the canonical Worker
@@ -40,6 +43,7 @@ function isWithinRoot(target, root) {
  * physical directory. The returned value remains a logical tool target.
  */
 export function scopeRuntimeTargetPath(params) {
+    assertRuntimePathNamespace(params.rawPath.trim());
     const workingDirectory = params.workingDirectory?.trim();
     if (!workingDirectory) {
         return params.rawPath;
@@ -48,6 +52,7 @@ export function scopeRuntimeTargetPath(params) {
     if (!requested) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.REQUIRED, "runtime_target_path_missing");
     }
+    assertRuntimePathNamespace(workingDirectory);
     const normalizedTarget = normalizeLogicalPath(requested);
     const normalizedWorkingDirectory = normalizeLogicalPath(workingDirectory);
     if (hasTraversalSegment(normalizedTarget) ||
@@ -55,7 +60,7 @@ export function scopeRuntimeTargetPath(params) {
         isAbsolute(normalizedWorkingDirectory)) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.TRAVERSAL, "runtime_target_path_traversal");
     }
-    const normalized = posix.normalize(normalizedTarget);
+    const normalized = normalizeRuntimePathForScope(requested);
     const scoped = isAbsolute(normalized) ||
         normalized === "workspace" ||
         normalized.startsWith("workspace/") ||
@@ -67,7 +72,7 @@ export function scopeRuntimeTargetPath(params) {
     // then enforce the call-owned physical scope for explicit forms as well.
     const resolvedWorkingDirectory = resolveRuntimeTargetPath(normalizedWorkingDirectory, params.sharedState);
     const resolvedTarget = resolveRuntimeTargetPath(scoped, params.sharedState);
-    if (!isWithinRoot(resolvedTarget, resolvedWorkingDirectory)) {
+    if (!isRuntimePathWithinRoot(resolvedTarget, resolvedWorkingDirectory)) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.OUTSIDE_WORKING_DIRECTORY, "runtime_target_path_outside_working_directory");
     }
     return scoped;
@@ -169,6 +174,7 @@ function resolveRuntimeToolPath(rawPath, options) {
     if (requested.includes("\0")) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.NULL_BYTE);
     }
+    assertRuntimePathNamespace(requested);
     const allowed = Object.freeze([...(options.allowedLocations ?? DEFAULT_TOOL_PATH_LOCATIONS)].filter((location, index, values) => values.indexOf(location) === index));
     if (allowed.length === 0) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.LOCATION_REQUIRED);
@@ -188,6 +194,8 @@ function resolveRuntimeToolPath(rawPath, options) {
     let selected;
     let lexicalTarget;
     if (workspaceRelative !== undefined) {
+        // Validate the alias payload before root resolution can hide its namespace.
+        assertRuntimePathNamespace(requested.slice("workspace/".length));
         const workspace = availableRoots.find(({ location }) => location === "workspace");
         if (!workspace) {
             throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.WORKSPACE_UNAVAILABLE);
@@ -198,7 +206,7 @@ function resolveRuntimeToolPath(rawPath, options) {
     else if (isAbsolute(requested)) {
         lexicalTarget = resolve(requested);
         const rootedMatch = availableRoots
-            .filter(({ root }) => isWithinRoot(lexicalTarget, root))
+            .filter(({ root }) => isRuntimePathWithinRoot(lexicalTarget, root))
             .sort((left, right) => right.root.length - left.root.length)[0];
         if (rootedMatch) {
             selected = rootedMatch;
@@ -219,12 +227,12 @@ function resolveRuntimeToolPath(rawPath, options) {
         selected = rootedDefault;
         lexicalTarget = resolve(selected.root, normalized === "." ? "" : normalized);
     }
-    if (!isWithinRoot(lexicalTarget, selected.root)) {
+    if (!isRuntimePathWithinRoot(lexicalTarget, selected.root)) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.OUTSIDE_CONFIGURED_ROOTS);
     }
     const absolutePath = resolveThroughExistingAncestor(lexicalTarget);
     const canonicalRoot = resolveThroughExistingAncestor(selected.root);
-    if (!isWithinRoot(absolutePath, canonicalRoot)) {
+    if (!isRuntimePathWithinRoot(absolutePath, canonicalRoot)) {
         throwRuntimeToolPathError(RUNTIME_TOOL_PATH_ERROR_CODES.SYMLINK_ESCAPE);
     }
     const relativePath = relative(canonicalRoot, absolutePath).replaceAll(sep, "/");

package/dist/src/runtime/capabilities/scheduling/create-operations.d.ts

@@ -5,6 +5,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>, Readonly<{
@@ -14,6 +15,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>, Readonly<{
@@ -23,6 +25,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>, Readonly<{
@@ -32,6 +35,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>, Readonly<{
@@ -41,6 +45,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>, Readonly<{
@@ -50,6 +55,7 @@ export declare const scheduleCreateOperations: readonly [Readonly<{
     selectionControlIds?: readonly string[];
     fixedParams?: Readonly<Record<string, import("../../../capabilities/tool-types.js").ToolNormalInvocationFixedValue>>;
     payload?: import("../../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+    attachmentInput?: import("../../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
     effect: import("../../../capabilities/tool-types.js").ToolNormalInvocationEffect;
     approval: import("../../../capabilities/tool-types.js").ToolNormalInvocationApproval;
 }>];

package/dist/src/runtime/capabilities/scheduling/job-list-page.d.ts

@@ -5,6 +5,9 @@ export declare function createSchedulerJobPage(jobs: readonly SchedulerJob[], pa
     limit?: unknown;
 }): {
     jobs: {
+        target?: Readonly<{
+            kind: "request";
+        }>;
         id: string;
         environmentId: string;
         sessionId: string;
@@ -13,7 +16,7 @@ export declare function createSchedulerJobPage(jobs: readonly SchedulerJob[], pa
         agentMode: import("../../../shared/types.js").AgentMode;
         toolPermissionMode: import("../../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
         timeZone: string;
-        schedule: import("../../scheduler/contracts.js").SchedulerSchedule;
+        schedule: import("../../scheduler/contracts.js").SchedulerTimedSchedule;
         state: import("../../scheduler/contracts.js").SchedulerJobState;
         createdAt: string;
         updatedAt: string;

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

@@ -9,6 +9,7 @@ import type { SchedulerRun, SchedulerService } from "./scheduler/contracts.js";
 import { SessionRequestAdmission } from "./request/session-admission.js";
 import type { RequestSteeringAppendResult } from "./request/request-steering.js";
 import type { PassiveLearningService } from "./passive-learning/contracts.js";
+import type { AutomationService } from "./automations/service.js";
 export type RuntimeEnvironmentServices = Readonly<{
     config: RuntimeConfig;
     sessions: SessionStore;
@@ -20,12 +21,13 @@ export type RuntimeEnvironmentServices = Readonly<{
     sessionMemoryCompactor: SessionMemoryCompactor;
     longTermMemory: LongTermMemoryService;
     passiveLearning?: PassiveLearningService;
+    automations?: AutomationService;
     scheduler?: SchedulerService;
     startScheduler?: () => Promise<void>;
     stopScheduler?: () => Promise<void>;
     requestAdmission?: SessionRequestAdmission;
 }>;
-export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering" | "abortSignal" | "claimFinalization" | "durableApprovals" | "approvalExecution">;
+export type RuntimeRequestOptions = Pick<RequestHandlerOptions, "toolApprovalController" | "requestSteering" | "abortSignal" | "claimFinalization" | "durableApprovals" | "approvalExecution" | "effectPersistence">;
 export type RuntimeRequestHandler = Readonly<{
     cancel?: (requestId: string, sessionId: string, wait?: import("./request/cancellation.js").SavedWaitCancellation) => Promise<import("./request/cancellation.js").RequestCancellationResult>;
     steer?: (requestId: string, input: Readonly<{
@@ -53,12 +55,13 @@ export type RuntimeDependencies = {
     sessionMemoryCompactor: SessionMemoryCompactor;
     longTermMemory: LongTermMemoryService;
     passiveLearning?: PassiveLearningService;
+    automations?: AutomationService;
     scheduler?: SchedulerService;
     startScheduler?: () => Promise<void>;
     stopScheduler?: () => Promise<void>;
     requestAdmission?: SessionRequestAdmission;
 };
-export type RuntimeDependencyOverrides = Partial<Omit<RuntimeDependencies, "config" | "scheduler" | "startScheduler" | "stopScheduler" | "requestAdmission">>;
+export type RuntimeDependencyOverrides = Partial<Omit<RuntimeDependencies, "config" | "scheduler" | "automations" | "startScheduler" | "stopScheduler" | "requestAdmission">>;
 export type RuntimeApplicationOverrides = RuntimeDependencyOverrides & {
     scheduledRequestOptions?: (run: SchedulerRun) => RuntimeRequestOptions;
 };

package/dist/src/runtime/context/canonical-capability-result.d.ts

@@ -0,0 +1,4 @@
+import { type RoleCallLedgerHead, type RoleCapabilityExecution } from "../orchestration/role-calls/index.js";
+import type { RequestToolResult } from "./request-tool-results.js";
+/** Exact validated ledger evidence, before consumer filtering or supersession. */
+export declare function projectCanonicalRequestToolResult(head: RoleCallLedgerHead, execution: RoleCapabilityExecution): RequestToolResult;

package/dist/src/runtime/context/canonical-capability-result.js

@@ -0,0 +1,80 @@
+import { isRoleCapabilityId, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../orchestration/role-calls/index.js";
+import { normalizeCapabilityAdapterResult } from "../orchestration/capability-adapters/result.js";
+import { projectAcceptedCapabilityAction } from "./accepted-capability-action.js";
+/** Exact validated ledger evidence, before consumer filtering or supersession. */
+export function projectCanonicalRequestToolResult(head, execution) {
+    const exactResult = normalizeCapabilityAdapterResult(execution.exactResult);
+    if (execution.status !== "settled" ||
+        typeof execution.executionId !== "string" ||
+        execution.executionId.length === 0 ||
+        typeof execution.callId !== "string" ||
+        execution.callId.length === 0 ||
+        !Number.isSafeInteger(execution.invocationAttempt) ||
+        execution.invocationAttempt < 1 ||
+        !isRoleCapabilityId(execution.capabilityId) ||
+        !isDeclaredEffect(execution.declaredEffect) ||
+        !isOutcome(execution.outcome) ||
+        !isObservedEffect(execution.observedEffect) ||
+        !isBoundedSummary(execution.summary) ||
+        !isOptionalBoundedReferenceData(execution.referenceData) ||
+        !isValidReferences(execution.references) ||
+        !exactResult.ok) {
+        throw new Error("request_tool_results_execution_invalid");
+    }
+    return Object.freeze({
+        executionId: execution.executionId,
+        callId: execution.callId,
+        invocationAttempt: execution.invocationAttempt,
+        capabilityId: execution.capabilityId,
+        declaredEffect: execution.declaredEffect,
+        outcome: execution.outcome,
+        observedEffect: execution.observedEffect,
+        summary: execution.summary,
+        ...(execution.referenceData
+            ? { referenceData: execution.referenceData }
+            : {}),
+        ...(execution.references
+            ? { references: Object.freeze([...execution.references]) }
+            : {}),
+        ...(execution.actionFingerprint
+            ? {
+                acceptedAction: projectAcceptedCapabilityAction(head, execution),
+            }
+            : {}),
+        adapterResult: exactResult.value,
+    });
+}
+function isDeclaredEffect(value) {
+    return value === "observation" || value === "mutation" || value === "mixed";
+}
+function isOutcome(value) {
+    return value === "succeeded" || value === "failed";
+}
+function isObservedEffect(value) {
+    return (value === "none" ||
+        value === "observation" ||
+        value === "mutation" ||
+        value === "indeterminate");
+}
+function isBoundedSummary(value) {
+    return (typeof value === "string" &&
+        value.trim().length > 0 &&
+        value.length <= ROLE_CALL_RESULT_MAX_LENGTH);
+}
+function isOptionalBoundedReferenceData(value) {
+    return (value === undefined ||
+        (typeof value === "string" &&
+            value.trim().length > 0 &&
+            value.length <= ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH));
+}
+function isValidReferences(value) {
+    return (value === undefined ||
+        (Array.isArray(value) &&
+            value.length <= ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX &&
+            value.every((reference) => reference.kind === "tool_target" &&
+                typeof reference.target === "string" &&
+                reference.target.trim().length > 0 &&
+                reference.target.length <=
+                    ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH) &&
+            new Set(value.map(({ target }) => target)).size === value.length));
+}

package/dist/src/runtime/context/capability-brief-readmission.js

@@ -4,9 +4,6 @@ import { resolveCapabilityBriefMessageHeadroom } from "./capability-brief-budget
 export function createCapabilityBriefReadmissionController(params) {
     const { controller } = params;
     return Object.freeze({
-        get compactionScope() {
-            return controller.compactionScope;
-        },
         project(messages) {
             const projected = controller.project(messages);
             const briefIndex = projected.findIndex(isCapabilityBriefMessage);
@@ -40,8 +37,8 @@ export function createCapabilityBriefReadmissionController(params) {
                 ...projected.slice(briefIndex + 1),
             ];
         },
-        prepare(messages) {
-            return controller.prepare(messages);
+        getStages() {
+            return controller.getStages();
         },
     });
 }

package/dist/src/runtime/context/capability-result-compaction-source.d.ts

@@ -0,0 +1,12 @@
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestToolResult } from "./request-tool-results.js";
+import { type SemanticCompactionSource } from "./semantic-compaction/contracts.js";
+/** Capture full immutable bytes once, independently of the evidence consumer. */
+export declare function createCapabilityResultCompactionSource(result: RequestToolResult): SemanticCompactionSource;
+export declare function projectCanonicalCapabilityResultCompactionSources(params: {
+    head: RoleCallLedgerHead;
+    callId: string;
+}): readonly SemanticCompactionSource[];
+/** The existing visible Worker dedup rule also defines canonical source bytes. */
+export declare function projectSingleCopyCapabilityResult(result: RequestToolResult): RequestToolResult;
+export declare function isReferenceDataRepresentedByAdapterResult(result: Pick<RequestToolResult, "referenceData" | "adapterResult">): boolean;

package/dist/src/runtime/context/capability-result-compaction-source.js

@@ -0,0 +1,61 @@
+import { projectCanonicalRequestToolResult } from "./canonical-capability-result.js";
+import { hasSuperContextContract } from "./super-context-policy.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+/** Capture full immutable bytes once, independently of the evidence consumer. */
+export function createCapabilityResultCompactionSource(result) {
+    if (!result.adapterResult)
+        throw new Error("context_compaction_source_adapter_required");
+    const exact = projectSingleCopyCapabilityResult(result);
+    const content = JSON.stringify({
+        executionId: exact.executionId,
+        callId: exact.callId,
+        invocationAttempt: exact.invocationAttempt,
+        capabilityId: exact.capabilityId,
+        declaredEffect: exact.declaredEffect,
+        outcome: exact.outcome,
+        observedEffect: exact.observedEffect,
+        summary: exact.summary,
+        ...(exact.referenceData ? { referenceData: exact.referenceData } : {}),
+        ...(exact.references ? { references: exact.references } : {}),
+        ...(exact.acceptedAction ? { acceptedAction: exact.acceptedAction } : {}),
+        adapterResult: exact.adapterResult,
+    });
+    return Object.freeze({
+        sourceRef: result.executionId,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+export function projectCanonicalCapabilityResultCompactionSources(params) {
+    if (!hasSuperContextContract(params.head.policy.authority, "delegated.worker")) {
+        throw new Error("context_compaction_source_policy_invalid");
+    }
+    const call = params.head.state.calls.find(({ callId }) => callId === params.callId);
+    if (!call || call.roleId !== "worker")
+        throw new Error("context_compaction_source_call_invalid");
+    return Object.freeze(params.head.state.capabilityExecutions
+        .filter((execution) => execution.callId === call.callId && execution.status === "settled")
+        .map((execution) => createCapabilityResultCompactionSource(projectCanonicalRequestToolResult(params.head, execution))));
+}
+/** The existing visible Worker dedup rule also defines canonical source bytes. */
+export function projectSingleCopyCapabilityResult(result) {
+    if (!isReferenceDataRepresentedByAdapterResult(result))
+        return result;
+    const { referenceData: _referenceData, ...singleCopyResult } = result;
+    return Object.freeze(singleCopyResult);
+}
+export function isReferenceDataRepresentedByAdapterResult(result) {
+    const referenceData = result.referenceData;
+    const adapterResult = result.adapterResult;
+    if (!referenceData || !adapterResult)
+        return false;
+    if (adapterResult.kind === "registered_tool_execution_result_v1") {
+        return adapterResult.result.output === referenceData;
+    }
+    if (adapterResult.kind !== "generic_capability_result_v1")
+        return false;
+    const payload = adapterResult.payload;
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload))
+        return false;
+    return payload.referenceData === referenceData;
+}

package/dist/src/runtime/context/compacted-capability-result-receipt.d.ts

@@ -0,0 +1,7 @@
+import type { RequestToolResult } from "./request-tool-results.js";
+type CompactedResultContent = Pick<RequestToolResult, "adapterResult" | "referenceData" | "summary">;
+/** Call only after exact source verification; independent supplements remain raw. */
+export declare function projectCompactedCapabilityResultReceipt<Result extends CompactedResultContent>(result: Result): Readonly<Omit<Omit<Result, "adapterResult"> & {
+    summary: string;
+}, "referenceData">>;
+export {};

package/dist/src/runtime/context/compacted-capability-result-receipt.js

@@ -0,0 +1,29 @@
+import { isReferenceDataRepresentedByAdapterResult } from "./capability-result-compaction-source.js";
+/** Call only after exact source verification; independent supplements remain raw. */
+export function projectCompactedCapabilityResultReceipt(result) {
+    const { adapterResult: _adapterResult, ...metadata } = result;
+    const receipt = {
+        ...metadata,
+        summary: isSummaryCoveredByCompactedResult(result)
+            ? "Result evidence is available in the verified compacted source."
+            : result.summary,
+    };
+    if (!isReferenceDataCoveredByCompactedResult(result))
+        return Object.freeze(receipt);
+    const { referenceData: _referenceData, ...coveredReceipt } = receipt;
+    return Object.freeze(coveredReceipt);
+}
+function isSummaryCoveredByCompactedResult(result) {
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return result.summary === result.adapterResult.result.output;
+}
+function isReferenceDataCoveredByCompactedResult(result) {
+    if (isReferenceDataRepresentedByAdapterResult(result))
+        return true;
+    if (!result.referenceData)
+        return false;
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return (result.referenceData === result.adapterResult.result.data?.mutationGrounding);
+}

package/dist/src/runtime/context/compaction-source-invariant.d.ts

@@ -0,0 +1,6 @@
+/** Keeps the bounded identity of rejected evidence, never its content. */
+export declare class CompactionSourceInvariantError extends Error {
+    readonly code: string;
+    readonly sourceRef: string | undefined;
+    constructor(code: string, sourceRef?: string);
+}

package/dist/src/runtime/context/compaction-source-invariant.js

@@ -0,0 +1,12 @@
+/** Keeps the bounded identity of rejected evidence, never its content. */
+export class CompactionSourceInvariantError extends Error {
+    code;
+    sourceRef;
+    constructor(code, sourceRef) {
+        super(code);
+        this.code = code;
+        this.name = "CompactionSourceInvariantError";
+        this.sourceRef =
+            sourceRef && sourceRef.length <= 256 ? sourceRef : undefined;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { type SemanticCompactionDigest } from "./semantic-compaction/contracts.js";
+import type { RequestContextCompactionStore } from "./semantic-compaction/store.js";
+type ExecutionEvidenceIdentity = Readonly<{
+    executionId: string;
+    callId: string;
+    invocationAttempt: number;
+    capabilityId: string;
+    adapterResult: unknown;
+}>;
+export type ExecutionCompactedSource = SemanticCompactionDigest & Readonly<{
+    executionId: string;
+}>;
+export type ExecutionCompactedSources = Readonly<{
+    scopeId: string;
+    sourceRevision: number;
+    sources: readonly ExecutionCompactedSource[];
+}>;
+type ExecutionEvidenceProjection = Readonly<{
+    requestId: string;
+    prompt: string;
+    objective: string;
+    callId: string;
+    store?: RequestContextCompactionStore;
+    results: readonly ExecutionEvidenceIdentity[];
+}>;
+/** Resolve only source digests; never transfer the root's continuation authority. */
+export declare function resolveExecutionCompactedSources(params: ExecutionEvidenceProjection): ExecutionCompactedSources | undefined;
+export declare function matchesCompactedExecutionResult(content: string, result: ExecutionEvidenceIdentity): boolean;
+export {};

package/dist/src/runtime/context/execution-compacted-evidence.js

@@ -0,0 +1,87 @@
+import { executionCompactionScopeId } from "./execution-compaction-objective.js";
+import { isDeepStrictEqual } from "node:util";
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+/** Resolve only source digests; never transfer the root's continuation authority. */
+export function resolveExecutionCompactedSources(params) {
+    const store = params.store;
+    if (!store)
+        return undefined;
+    const checkpoint = store
+        .findByCallIds([params.callId])
+        .find((candidate) => canReuseExecutionCheckpoint(candidate, params));
+    if (!checkpoint)
+        return undefined;
+    const digests = new Map(checkpoint.sourceDigests.map((digest) => [digest.sourceRef, digest]));
+    const sources = [];
+    for (const result of params.results) {
+        const digest = digests.get(`tool-result:${result.executionId}`);
+        if (!digest)
+            continue;
+        if (result.callId !== checkpoint.callId)
+            continue;
+        const source = store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+        if (!source || !matchesCompactedExecutionResult(source.content, result))
+            continue;
+        sources.push(Object.freeze({ ...digest, executionId: result.executionId }));
+    }
+    if (sources.length === 0)
+        return undefined;
+    return Object.freeze({
+        scopeId: checkpoint.scopeId,
+        sourceRevision: checkpoint.sourceRevision,
+        sources: Object.freeze(sources),
+    });
+}
+function canReuseExecutionCheckpoint(checkpoint, params) {
+    if (checkpoint.requestId !== params.requestId)
+        return false;
+    if (checkpoint.callId !== params.callId)
+        return false;
+    if (checkpoint.roleId !== "supervisor")
+        return false;
+    if (checkpoint.scopeId !== executionCompactionScopeId(params))
+        return false;
+    if (checkpoint.currentRequestFingerprint !==
+        createSemanticCompactionSha256Fingerprint(params.prompt))
+        return false;
+    if (checkpoint.objectiveFingerprint !==
+        createSemanticCompactionSha256Fingerprint(params.objective))
+        return false;
+    return checkpoint.allowedConsumers.includes(MODEL_STEPS.EXECUTION_DECISION);
+}
+export function matchesCompactedExecutionResult(content, result) {
+    const message = readCompactionRecord(content);
+    if (message?.role !== "tool")
+        return false;
+    if (message.toolCallId !== result.executionId)
+        return false;
+    if (message.attachments !== undefined)
+        return false;
+    const envelope = readCompactionRecord(message.content);
+    if (envelope?.kind !== "runtime_execution_capability_result_v1")
+        return false;
+    if (envelope.invocationAttempt !== result.invocationAttempt)
+        return false;
+    const covered = compactionRecord(envelope.result);
+    if (covered?.executionId !== result.executionId)
+        return false;
+    if (covered.capabilityId !== result.capabilityId)
+        return false;
+    return isDeepStrictEqual(covered.adapterResult, result.adapterResult);
+}
+function readCompactionRecord(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return compactionRecord(JSON.parse(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function compactionRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}

package/dist/src/runtime/context/execution-compaction-objective.d.ts

@@ -0,0 +1,11 @@
+/** One accepted request objective shared by EA and its evidence consumers. */
+export declare function projectExecutionCompactionObjective(prompt: string, updates: readonly Readonly<{
+    text: string;
+}>[]): string;
+/** A changed objective gets a fresh lane; prior checkpoints retain their binding. */
+export declare function executionCompactionScopeId(params: Readonly<{
+    callId: string;
+    prompt: string;
+    objective: string;
+    scopeSuffix?: string;
+}>): string;

package/dist/src/runtime/context/execution-compaction-objective.js

@@ -0,0 +1,12 @@
+import { createSemanticCompactionSha256Fingerprint } from "./semantic-compaction/contracts.js";
+/** One accepted request objective shared by EA and its evidence consumers. */
+export function projectExecutionCompactionObjective(prompt, updates) {
+    return [prompt, ...updates.map(({ text }) => text)].join("\n");
+}
+/** A changed objective gets a fresh lane; prior checkpoints retain their binding. */
+export function executionCompactionScopeId(params) {
+    const scope = `role:supervisor:${params.callId}:${params.scopeSuffix ?? "continuation"}`;
+    if (params.objective === params.prompt)
+        return scope;
+    return `${scope}:objective:${createSemanticCompactionSha256Fingerprint(params.objective)}`;
+}

package/dist/src/runtime/context/model-step-compaction.d.ts

@@ -1,3 +1,6 @@
+import { type SuperCompactionFailureOwner } from "./super-compaction-failure-owner.js";
+import type { SuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
 import type { ModelStepContextCompactionController } from "../model/model-step-port.js";
 import { type SemanticCompactionSource, type SemanticCompactionRequest } from "./semantic-compaction/index.js";
@@ -6,12 +9,18 @@ type ModelStepCompactionOptions = Readonly<{
         roleId: string;
         callId: string;
         objective: string | null;
+        activationCount?: number;
     }>;
     sourceRevision: number;
     allowedConsumers: readonly ModelStep[];
     scopeId?: string;
     scopeSuffix?: string;
     resultSourceOverrides?: readonly SemanticCompactionSource[];
+    superWorkerCompaction?: SuperWorkerCompactionSidecar;
+    requireSuperWorkerSources?: boolean;
+    consumer?: ModelStep;
+    superFailureOwner?: SuperCompactionFailureOwner;
+    hasVerifiedCompactedEvidence?(messages: readonly ChatMessage[]): boolean;
 }>;
 export declare function createModelStepCompactionController(request: SemanticCompactionRequest, options: ModelStepCompactionOptions): ModelStepContextCompactionController;
 export {};