@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/model/model-step-acceptance.js

@@ -0,0 +1,28 @@
+/** Bound asynchronous validation to the same deadline as its provider attempt.
+ * The callback must also pass this signal to its own asynchronous work.
+ */
+export function acceptModelStepOutput(accept, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve()
+            .then(() => {
+            signal.throwIfAborted();
+            return accept();
+        })
+            .then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted)
+                reject(signal.reason);
+            else
+                resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(signal.aborted ? signal.reason : error);
+        });
+    });
+}

package/dist/src/runtime/model/model-step-port.d.ts

@@ -1,5 +1,7 @@
 import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
+import type { ModelStepContextCompactionController } from "./context-compaction-contracts.js";
+export type { ModelStepCompactionScope, ModelStepCompactionStage, ModelStepCompactionStageOutcome, ModelStepContextCompactionController, ModelStepContextCompactionPreparation, } from "./context-compaction-contracts.js";
 export type ModelStepOutputDiagnostics = Readonly<{
     outputLength: number;
     /** Runtime-owned steering snapshot used by this provider attempt. */
@@ -11,20 +13,6 @@ export type ModelStepOutputDiagnostics = Readonly<{
     providerOutputTokens?: number;
     providerTotalTokens?: number;
 }>;
-export type ModelStepContextCompactionPreparation = Readonly<{
-    messages: ChatMessage[];
-    commit(): void | Promise<void>;
-    scopeId: string;
-    sourceRevision: number | string;
-    coveredSourceCount: number;
-}>;
-export type ModelStepContextCompactionController = Readonly<{
-    compactionScope: "active_request" | "session_history";
-    /** Replaces already-covered exact working messages before assessment. */
-    project(messages: readonly ChatMessage[]): ChatMessage[];
-    /** Generates one replacement checkpoint without committing it yet. */
-    prepare(messages: readonly ChatMessage[]): Promise<ModelStepContextCompactionPreparation>;
-}>;
 export type ModelStepInvocationInput<T> = Readonly<{
     modelStep: ModelStep;
     messages: ChatMessage[];
@@ -35,7 +23,8 @@ export type ModelStepInvocationInput<T> = Readonly<{
     /** Exact input bypasses compaction, but must fit the shared input budget. */
     contextRetention?: "exact";
     contextCompaction?: ModelStepContextCompactionController;
-    accept(text: string, diagnostics: ModelStepOutputDiagnostics): T;
+    /** Async validators must forward this attempt signal to their own work. */
+    accept(text: string, diagnostics: ModelStepOutputDiagnostics, abortSignal: AbortSignal): T | Promise<T>;
 }>;
 /** Request-owned port shared by every model step in one accepted request. */
 export type RequestModelStepPort = Readonly<{

package/dist/src/runtime/model/model-step-steering.d.ts

@@ -1,4 +1,4 @@
-import type { RequestSteeringInbox } from "../request/request-steering.js";
+import type { RequestSteeringInbox, RequestSteeringSnapshot } from "../request/request-steering.js";
 /** Returns a decision-bound invocation to its caller when that decision is stale. */
 export declare class ModelStepSteeringSupersededError extends Error {
     readonly boundSteeringVersion: number;
@@ -6,3 +6,16 @@ export declare class ModelStepSteeringSupersededError extends Error {
 }
 export declare function isModelStepSteeringSuperseded(error: unknown): error is ModelStepSteeringSupersededError;
 export declare function assertBoundModelStepSteeringCurrent(requestSteering: RequestSteeringInbox, boundSteeringVersion: number | undefined): void;
+/** Internal control transfer, caught before it can leave the invocation loop. */
+export declare class ModelStepAdmissionSuperseded extends Error {
+    readonly steeringSnapshot: RequestSteeringSnapshot;
+    constructor(steeringSnapshot: RequestSteeringSnapshot);
+}
+export declare function assertModelStepAdmissionCurrent(params: {
+    abortSignal: AbortSignal;
+    requestSteering: RequestSteeringInbox;
+    boundSteeringVersion: number | undefined;
+    ownsRequestSteering: boolean;
+    steeringSnapshot: RequestSteeringSnapshot;
+}): void;
+export declare function isCompactionSteeringSuperseded(error: unknown): boolean;

package/dist/src/runtime/model/model-step-steering.js

@@ -17,3 +17,26 @@ export function assertBoundModelStepSteeringCurrent(requestSteering, boundSteeri
         return;
     throw new ModelStepSteeringSupersededError(boundSteeringVersion);
 }
+/** Internal control transfer, caught before it can leave the invocation loop. */
+export class ModelStepAdmissionSuperseded extends Error {
+    steeringSnapshot;
+    constructor(steeringSnapshot) {
+        super("model_step_steering_superseded");
+        this.steeringSnapshot = steeringSnapshot;
+        this.name = "ModelStepAdmissionSuperseded";
+    }
+}
+export function assertModelStepAdmissionCurrent(params) {
+    params.abortSignal.throwIfAborted();
+    assertBoundModelStepSteeringCurrent(params.requestSteering, params.boundSteeringVersion);
+    if (!params.ownsRequestSteering)
+        return;
+    if (params.requestSteering.isCurrent(params.steeringSnapshot.version))
+        return;
+    throw new ModelStepAdmissionSuperseded(params.steeringSnapshot);
+}
+export function isCompactionSteeringSuperseded(error) {
+    if (error instanceof ModelStepAdmissionSuperseded)
+        return true;
+    return isModelStepSteeringSuperseded(error);
+}

package/dist/src/runtime/observability/request-control-diagnostics.d.ts

@@ -0,0 +1,6 @@
+export { classifyRuntimeErrorType as diagnosticErrorType } from "./error-type.js";
+export type RequestControlDiagnosticFields = Readonly<Record<string, string | number | boolean | null | undefined>>;
+/** Diagnostic identity only; never used for request admission or ownership. */
+export declare function createRequestControlDiagnosticId(prefix: string): string;
+/** Best-effort, content-free diagnostics must never change a control result. */
+export declare function traceRequestControl(scope: string, event: string, fields?: RequestControlDiagnosticFields): void;

package/dist/src/runtime/observability/request-control-diagnostics.js

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { traceDebug } from "./debug-logger.js";
+export { classifyRuntimeErrorType as diagnosticErrorType } from "./error-type.js";
+let fallbackId = 0;
+/** Diagnostic identity only; never used for request admission or ownership. */
+export function createRequestControlDiagnosticId(prefix) {
+    try {
+        return `${prefix}-${randomUUID()}`;
+    }
+    catch {
+        return `${prefix}-${process.pid}-${Date.now()}-${++fallbackId}`;
+    }
+}
+const processInstanceId = createRequestControlDiagnosticId("process");
+let packageIdentity;
+function readPackageIdentity() {
+    // Source and compiled layouts. Installed packages do not require a Git checkout.
+    for (const relative of [
+        "../../../package.json",
+        "../../../../package.json",
+    ]) {
+        try {
+            const value = JSON.parse(readFileSync(new URL(relative, import.meta.url), "utf8"));
+            if (value.name !== "@abot-ai/runtime")
+                continue;
+            return {
+                runtimeVersion: typeof value.version === "string" ? value.version : "unknown",
+                packageRevision: typeof value.gitHead === "string" ? value.gitHead : null,
+            };
+        }
+        catch {
+            // Metadata may be absent in an embedded host; it cannot block execution.
+        }
+    }
+    return { runtimeVersion: "unknown", packageRevision: null };
+}
+/** Best-effort, content-free diagnostics must never change a control result. */
+export function traceRequestControl(scope, event, fields = {}) {
+    try {
+        packageIdentity ??= readPackageIdentity();
+        traceDebug(scope, event, {
+            ...packageIdentity,
+            pid: process.pid,
+            processInstanceId,
+            ...fields,
+        });
+    }
+    catch {
+        // Includes synchronous serialization/console failures; disk writes are best effort.
+    }
+}

package/dist/src/runtime/orchestration/capability-adapters/result.d.ts

@@ -1,3 +1,4 @@
+import { type ToolContextTextField } from "../../../capabilities/tool-context-text.js";
 import { type ToolImageEvidence } from "../../../capabilities/tool-media.js";
 export declare const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES: number;
 export type CapabilityJsonPrimitive = string | number | boolean | null;
@@ -10,6 +11,7 @@ export type CapabilityResultReference = Readonly<{
     target: string;
 }>;
 export type CanonicalToolExecutionResult = Readonly<{
+    contextTextFields?: readonly ToolContextTextField[];
     media?: readonly ToolImageEvidence[];
     ok: boolean;
     tool: string;
@@ -65,7 +67,8 @@ export type CapabilityAdapterResultNormalization = Readonly<{
 /**
  * Captures one typed exact result without truncating or semantically rewriting
  * plugin-authored content. Bounds come from the explicit envelope schema and
- * the hard serialized-result producer limit.
+ * the metadata envelope limit. Declared text stays exact and is budgeted at
+ * model invocation, where the existing context compactor can see it.
  */
 export declare function normalizeCapabilityAdapterResult(input: unknown): CapabilityAdapterResultNormalization;
 /**

package/dist/src/runtime/orchestration/capability-adapters/result.js

@@ -1,10 +1,13 @@
+import { assessResultEnvelopeBytes, CAPABILITY_RESULT_ENVELOPE_MAX_BYTES } from "../../../capabilities/result-budget.js";
+import { hasValidToolContextText, measureToolContextTextBytes, } from "../../../capabilities/tool-context-text.js";
 import { isToolResultMedia } from "../../../capabilities/tool-media.js";
 import { ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, } from "../role-calls/contracts.js";
-export const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES = 256 * 1024;
+export const CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 /**
  * Captures one typed exact result without truncating or semantically rewriting
  * plugin-authored content. Bounds come from the explicit envelope schema and
- * the hard serialized-result producer limit.
+ * the metadata envelope limit. Declared text stays exact and is budgeted at
+ * model invocation, where the existing context compactor can see it.
  */
 export function normalizeCapabilityAdapterResult(input) {
     try {
@@ -152,6 +155,7 @@ function captureToolExecutionResult(input) {
             "error",
             "errorCode",
             "media",
+            "contextTextFields",
         ]) ||
         typeof input.ok !== "boolean" ||
         typeof input.tool !== "string" ||
@@ -168,6 +172,7 @@ function captureToolExecutionResult(input) {
         (input.errorCode !== undefined && typeof input.errorCode !== "string") ||
         !validActions(input.actions) ||
         !isToolResultMedia(input.media) ||
+        !hasValidToolContextText(input) ||
         !validToolData(input.data)) {
         return undefined;
     }
@@ -299,11 +304,10 @@ function invalid(code) {
     return Object.freeze({ ok: false, code });
 }
 function acceptBoundedResult(value) {
-    const serialized = JSON.stringify(value);
-    if (serialized === undefined)
-        return invalid("result_not_json_safe");
-    if (Buffer.byteLength(serialized, "utf8") >
-        CAPABILITY_ADAPTER_RESULT_SERIALIZED_MAX_BYTES) {
+    const contextTextBytes = value.kind === "registered_tool_execution_result_v1"
+        ? measureToolContextTextBytes(value.result)
+        : 0;
+    if (!assessResultEnvelopeBytes(value, contextTextBytes).fits) {
         return invalid("result_too_large");
     }
     return Object.freeze({ ok: true, value });

package/dist/src/runtime/orchestration/role-calls/child-return.d.ts

@@ -1,4 +1,4 @@
-import { type RoleCallCommitEffect, type RoleCallLedger, type RoleCallLedgerCommitResult, type RoleCallLedgerHead, type RoleCallWorkerCapabilityScope } from "./contracts.js";
+import { type RoleCallCommitEffect, type RoleCallLedger, type RoleCallLedgerCommitResult, type RoleCallLedgerHead, type RoleCallPolicy, type RoleCallState, type RoleCallWorkerCapabilityScope } from "./contracts.js";
 import { type RuntimeDelegateRoleId } from "../roles.js";
 import { type RoleCallResultReceipt } from "./result-receipt.js";
 import { type RoleCallWorkResultLineage } from "./work-result-lineage.js";
@@ -34,3 +34,7 @@ export type RoleCallChildReturnCommit = Readonly<{
 }>;
 export declare function requireRoleCallChildReturnCommit(commit: RoleCallLedgerCommitResult): RoleCallChildReturnCommit;
 export declare function projectRoleChildReturnContext(ledger: RoleCallLedger, commit: RoleCallLedgerCommitResult): RoleChildReturnContext;
+export declare function projectStoredCompletedRoleChild(state: RoleCallState, refs: Readonly<{
+    callerCallId: string;
+    childCallId: string;
+}>, policy: RoleCallPolicy): CompletedRoleChildResult;

package/dist/src/runtime/orchestration/role-calls/child-return.js

@@ -45,12 +45,12 @@ export function projectRoleChildReturnContext(ledger, commit) {
     });
 }
 function projectCompletedChildren(state, caller, policy) {
-    return Object.freeze(caller.childCallIds.map((completedChildCallId) => projectCompletedChild(state, {
+    return Object.freeze(caller.childCallIds.map((completedChildCallId) => projectStoredCompletedRoleChild(state, {
         callerCallId: caller.callId,
         childCallId: completedChildCallId,
     }, policy)));
 }
-function projectCompletedChild(state, refs, policy) {
+export function projectStoredCompletedRoleChild(state, refs, policy) {
     const child = state.calls.find((call) => call.callId === refs.childCallId);
     const result = state.results.find((candidate) => candidate.resultRef === child?.resultRef);
     if (child?.status !== "completed" ||

package/dist/src/runtime/orchestration/worker-capabilities/binding/invocation-preparation.js

@@ -17,14 +17,10 @@ export class CapabilityInvocationPreparer {
     #byCapabilityId;
     #capabilityScope;
     #diagnostic;
-    #workerPrincipal;
     constructor(params) {
         this.#byCapabilityId = params.byCapabilityId;
         this.#capabilityScope = params.capabilityScope;
         this.#diagnostic = params.diagnostic;
-        this.#workerPrincipal =
-            params.boundCall.roleId === "worker" &&
-                params.boundCall.parentCallId !== null;
     }
     prepareSingle(input) {
         const adapter = this.#resolveAvailableAdapter(input.capabilityId, SINGLE_CAPABILITY_LOOKUP_ISSUES);
@@ -39,7 +35,6 @@ export class CapabilityInvocationPreparer {
         const authoringObjective = normalizeAuthoringObjective({
             input,
             descriptor: adapter.descriptor,
-            workerPrincipal: this.#workerPrincipal,
         });
         if (!authoringObjective.ok) {
             this.#rejectSelection(authoringObjective.issueCode, input.capabilityId);
@@ -78,7 +73,6 @@ export class CapabilityInvocationPreparer {
         const authoringObjective = normalizeAuthoringObjective({
             input: candidate,
             descriptor: adapter.descriptor,
-            workerPrincipal: this.#workerPrincipal,
         });
         if (!authoringObjective.ok) {
             this.#rejectSelection(`batch_${authoringObjective.issueCode}`, candidate.capabilityId);
@@ -139,8 +133,7 @@ function normalizeCapabilityIntent(input) {
 }
 function normalizeAuthoringObjective(input) {
     const supplied = Object.hasOwn(input.input, "authoringObjective");
-    const required = input.workerPrincipal &&
-        input.descriptor.requiresPayloadAuthoringObjective === true;
+    const required = input.descriptor.requiresPayloadAuthoringObjective === true;
     if (!required && supplied) {
         return { ok: false, issueCode: "authoring_objective_forbidden" };
     }

package/dist/src/runtime/orchestration/worker-capabilities/contracts.d.ts

@@ -12,7 +12,7 @@ export declare const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export declare const WORKER_CAPABILITY_COUNT_MAX = 128;
 export declare const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export declare const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export declare const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4096;
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export declare const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export declare const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;
@@ -95,7 +95,7 @@ export type WorkerCapabilityDescriptor = Readonly<{
     routingCapability?: ToolRoutingCapability;
     /** Manifest-owned development phases served by this capability. */
     developmentRoles?: readonly ToolDevelopmentRole[];
-    /** Canonical payload contract requires a Worker authoring receipt. */
+    /** Canonical payload contract requires an accepted authoring assignment. */
     requiresPayloadAuthoringObjective?: true;
 }>;
 export type WorkerCapabilityControls = Readonly<Record<string, unknown>>;
@@ -145,7 +145,7 @@ export type WorkerCapabilityAdapterExecutionInput<TContext> = Readonly<{
     executionId: string;
     /** Client-facing presentation metadata for lifecycle events only. */
     intent: string;
-    /** Worker-only payload assignment; forbidden for root and non-payload calls. */
+    /** Accepted payload assignment; forbidden for non-payload calls. */
     authoringObjective?: string;
     controls: WorkerCapabilityControls;
     settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
@@ -266,4 +266,3 @@ export type WorkerCapabilityBinding<TContext> = Readonly<{
         }>[];
     }>): Promise<WorkerCapabilityBatchAttemptReference>;
 }>;
-export {};

package/dist/src/runtime/orchestration/worker-capabilities/contracts.js

@@ -8,7 +8,7 @@ export const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
 export const WORKER_CAPABILITY_COUNT_MAX = 128;
 export const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
-export const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4_096;
+export { TOOL_NORMAL_INVOCATION_STRING_MAX_LENGTH as WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH, } from "../../../capabilities/normal-invocation/contracts.js";
 export const WORKER_CAPABILITY_CONTROL_ENUM_MAX_VALUES = 64;
 export const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;

package/dist/src/runtime/orchestration/worker-capabilities/execution/context-projection.js

@@ -1,5 +1,6 @@
 import { traceWorkerCapabilityContextProjected, traceWorkerCapabilityContextRejected, } from "../diagnostics.js";
 import { projectWorkerSettledCapabilityResults } from "../settled-results.js";
+import { bindSuperWorkerCompactionSources } from "../../../context/super-worker-compaction-sidecar.js";
 import { assertWorkerCapabilityWithinScope, WorkerCapabilityScopeError, } from "../scope.js";
 export function assertExecutionCapabilityScope(projection, descriptor, diagnostic) {
     try {
@@ -32,7 +33,7 @@ export function projectExecutionSettledCapabilityResults(params) {
     for (const descriptor of params.descriptors) {
         traceWorkerCapabilityContextProjected(params.diagnostic, descriptor, settledCapabilityResults);
     }
-    return settledCapabilityResults;
+    return bindSuperWorkerCompactionSources([...settledCapabilityResults], params.head, params.call.callId);
 }
 function settledResultProjectionIssueCode(error) {
     if (!(error instanceof Error)) {

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.js

@@ -2,21 +2,21 @@ import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js
 import { isWorkerCapabilityPayloadSourceProvenanceValid } from "./payload-source-provenance.js";
 /** Validates payload assignment ownership before any model boundary is built. */
 export function isWorkerCapabilityPayloadAssignmentValid(input, principalKind, requestId) {
-    if (principalKind === "root") {
-        return (input.assignmentProvenance === undefined &&
-            !Object.hasOwn(input, "authoringObjective") &&
-            hasExecutionId(input.executionId));
-    }
     if (!hasExecutionId(input.executionId))
         return false;
-    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
-        return false;
-    }
     if (input.descriptor.requiresPayloadAuthoringObjective !== true)
         return false;
     if (!Object.hasOwn(input, "authoringObjective"))
         return false;
-    return isValidAuthoringObjective(input.authoringObjective);
+    if (!isValidAuthoringObjective(input.authoringObjective))
+        return false;
+    if (principalKind === "root") {
+        return input.assignmentProvenance === undefined;
+    }
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
+        return false;
+    }
+    return true;
 }
 function hasExecutionId(executionId) {
     return typeof executionId === "string" && executionId.length > 0;

package/dist/src/runtime/orchestration/worker-capabilities/payload-author.js

@@ -1,9 +1,11 @@
+import { immutableSnapshot } from "./payload-context-snapshot.js";
+import { projectWorkerPayloadCompactionInput } from "./payload-compaction-transport.js";
 import { isRoleCapabilityId, isRoleCallResultText, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CAPABILITY_EXECUTION_LIMIT_MAX, ROLE_CALL_RESULT_MAX_LENGTH, } from "../role-calls/index.js";
 import { normalizeCapabilityAdapterResult } from "../capability-adapters/result.js";
 import { traceWorkerCapabilityPayloadCompleted, traceWorkerCapabilityPayloadFailed, traceWorkerCapabilityPayloadStarted, } from "./payload-diagnostics.js";
 import { WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, WorkerCapabilityPayloadBudgetExceededError, WorkerCapabilityPayloadValidationError, } from "./payload-contracts.js";
 import { ROOT_CAPABILITY_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, } from "./payload-instructions.js";
-import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
+import { normalizePayloadBody } from "./payload-body-normalization.js";
 import { isRuntimeDelegateRoleId } from "../roles.js";
 import { projectWorkerPayloadRequestSourceProjection } from "./payload-source-provenance.js";
 import { isWorkerCapabilityPayloadAssignmentValid } from "./payload-assignment-validation.js";
@@ -80,6 +82,7 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             let output;
             try {
                 output = await params.model.invoke({
+                    ...projectWorkerPayloadCompactionInput(input, params.requestId),
                     executionId: input.executionId,
                     requestSourceProjection: "root" in context
                         ? "full_request"
@@ -107,10 +110,11 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             if (typeof output !== "string") {
                 return failure(diagnostic, "payload_model_output_invalid");
             }
-            const body = normalizeAuthoredBody(output, input.contract.responseFormat);
-            if (body === undefined) {
+            const normalized = normalizePayloadBody(output, input.contract.responseFormat);
+            if (!normalized.ok) {
                 return failure(diagnostic, "payload_model_output_invalid");
             }
+            const body = normalized.body;
             const payloadBytes = Buffer.byteLength(body, "utf8");
             if (payloadBytes < input.contract.minBytes) {
                 return failure(diagnostic, "payload_body_too_small");
@@ -186,6 +190,7 @@ function capturePayloadContext(input, capabilityAuthorities, requestId) {
             acceptedCapability: {
                 capabilityId: input.descriptor.capabilityId,
                 summary: input.descriptor.summary,
+                authoringObjective: input.authoringObjective,
                 controls: input.controls,
             },
             ...sharedContext,
@@ -330,22 +335,6 @@ function normalizePayloadContextScope(input) {
         ? input
         : undefined;
 }
-function normalizeAuthoredBody(output, responseFormat) {
-    if (!responseFormat) {
-        return output;
-    }
-    try {
-        const parsed = JSON.parse(output);
-        if (responseFormat !== "json" &&
-            validateJsonSchemaValue(responseFormat, parsed)) {
-            return undefined;
-        }
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return undefined;
-    }
-}
 function validResponseFormat(input) {
     return input === undefined || input === "json" || isPlainRecord(input);
 }
@@ -354,7 +343,7 @@ function validPayloadStage(input) {
         (Number.isSafeInteger(input.index) &&
             input.index > 0 &&
             Number.isSafeInteger(input.count) &&
-            input.count > 1 &&
+            input.count >= 1 &&
             input.index <= input.count &&
             typeof input.outputParam === "string" &&
             input.outputParam.trim().length > 0 &&
@@ -562,9 +551,6 @@ function failure(diagnostic, code, error) {
     traceWorkerCapabilityPayloadFailed(diagnostic, code, error);
     return Object.freeze({ status: "failed", code });
 }
-function immutableSnapshot(value) {
-    return deepFreeze(structuredClone(value));
-}
 function payloadAbort(reason) {
     const error = reason instanceof Error
         ? new Error(reason.message, { cause: reason })
@@ -572,13 +558,3 @@ function payloadAbort(reason) {
     error.name = "AbortError";
     return error;
 }
-function deepFreeze(value, seen = new WeakSet()) {
-    if (typeof value !== "object" || value === null || seen.has(value)) {
-        return value;
-    }
-    seen.add(value);
-    for (const child of Object.values(value)) {
-        deepFreeze(child, seen);
-    }
-    return Object.freeze(value);
-}

package/dist/src/runtime/orchestration/worker-capabilities/payload-body-normalization.d.ts

@@ -0,0 +1,12 @@
+import { type JsonSchemaValueValidationIssue } from "../../model/json-schema-value.js";
+import type { WorkerCapabilityPayloadResponseFormat } from "./payload-contracts.js";
+type PayloadBodyNormalization = Readonly<{
+    ok: true;
+    body: string;
+}> | Readonly<{
+    ok: false;
+    issue: JsonSchemaValueValidationIssue;
+}>;
+/** Normalizes declared JSON payloads without discarding repeated members. */
+export declare function normalizePayloadBody(body: string, responseFormat: WorkerCapabilityPayloadResponseFormat | undefined): PayloadBodyNormalization;
+export {};

package/dist/src/runtime/orchestration/worker-capabilities/payload-body-normalization.js

@@ -0,0 +1,80 @@
+import { validateJsonSchemaValue, } from "../../model/json-schema-value.js";
+/** Normalizes declared JSON payloads without discarding repeated members. */
+export function normalizePayloadBody(body, responseFormat) {
+    if (!responseFormat)
+        return Object.freeze({ ok: true, body });
+    try {
+        if (hasDuplicateJsonObjectMembers(body)) {
+            return invalidPayloadJson("JSON object member names must be unique within each object.");
+        }
+        const parsed = JSON.parse(body);
+        const issue = responseFormat === "json"
+            ? undefined
+            : validateJsonSchemaValue(responseFormat, parsed);
+        if (issue)
+            return Object.freeze({ ok: false, issue });
+        return Object.freeze({ ok: true, body: JSON.stringify(parsed) });
+    }
+    catch {
+        return invalidPayloadJson("Return one valid JSON value matching the frozen response format.");
+    }
+}
+function invalidPayloadJson(message) {
+    return Object.freeze({
+        ok: false,
+        issue: Object.freeze({ path: "output", message }),
+    });
+}
+/** Only checks member identity; JSON.parse remains the syntax/value decoder. */
+function hasDuplicateJsonObjectMembers(body) {
+    const containers = [];
+    for (let offset = 0; offset < body.length; offset += 1) {
+        const token = body[offset];
+        if (token === "{") {
+            containers.push(new Set());
+            continue;
+        }
+        if (token === "[") {
+            containers.push(undefined);
+            continue;
+        }
+        if (token === "}" || token === "]") {
+            containers.pop();
+            continue;
+        }
+        if (token !== '"')
+            continue;
+        const start = offset;
+        const end = jsonStringEnd(body, start);
+        offset = end;
+        const members = containers.at(-1);
+        if (!isJsonObjectMember(body, end, members))
+            continue;
+        const member = JSON.parse(body.slice(start, end + 1));
+        if (members.has(member))
+            return true;
+        members.add(member);
+    }
+    return false;
+}
+function isJsonObjectMember(body, stringEnd, members) {
+    if (!members)
+        return false;
+    let next = stringEnd + 1;
+    while (/[ \t\r\n]/u.test(body[next] ?? ""))
+        next += 1;
+    return body[next] === ":";
+}
+function jsonStringEnd(body, start) {
+    let offset = start + 1;
+    while (offset < body.length) {
+        if (body[offset] === "\\") {
+            offset += 2;
+            continue;
+        }
+        if (body[offset] === '"')
+            return offset;
+        offset += 1;
+    }
+    throw new SyntaxError("Unterminated JSON string.");
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerCapabilityPayloadAuthor, WorkerCapabilityPayloadModelRequest } from "./payload-contracts.js";
+/** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
+export declare function projectWorkerPayloadCompactionInput(input: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0], requestId: string): Pick<WorkerCapabilityPayloadModelRequest, "superWorkerCompaction">;

package/dist/src/runtime/orchestration/worker-capabilities/payload-compaction-transport.js

@@ -0,0 +1,14 @@
+import { assertSuperWorkerCompactionSidecarBinding, readSuperWorkerCompactionSidecar, } from "../../context/super-worker-compaction-sidecar.js";
+/** Runtime-only sidecar bypasses the cloned/model-visible payload context. */
+export function projectWorkerPayloadCompactionInput(input, requestId) {
+    if (input.call.roleId !== "worker")
+        return {};
+    const sidecar = readSuperWorkerCompactionSidecar(input.settledCapabilityResults);
+    if (!sidecar)
+        return {};
+    assertSuperWorkerCompactionSidecarBinding(sidecar, {
+        requestId,
+        callId: input.call.callId,
+    });
+    return { superWorkerCompaction: sidecar };
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-context-snapshot.d.ts

@@ -0,0 +1,2 @@
+/** Captures payload data without retaining mutable adapter-owned objects. */
+export declare function immutableSnapshot<T>(value: T): T;

package/dist/src/runtime/orchestration/worker-capabilities/payload-context-snapshot.js

@@ -0,0 +1,12 @@
+/** Captures payload data without retaining mutable adapter-owned objects. */
+export function immutableSnapshot(value) {
+    return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}