@sema-agent/core 7.5.1 → 7.6.0

package/dist/core/runner/assemble-result.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage } from "../../internal/llm.js";
-import type { NestedUsage, TaskResult, TaskSpec } from "../types.js";
+import type { NestedUsage, PausedCause, TaskResult, TaskSpec, TerminalCause } from "../types.js";
 /** Per-task usage/cost accumulator (filled across the run loop, surfaced as `TaskResult.stats`). */
 export interface Stats {
     turns: number;
@@ -194,40 +194,16 @@ export interface ResultFlags {
      *  NOT `suspended` — slotted ABOVE `suspendRef` and the aborted branches (this suspend never minted a
      *  checkpoint, so `suspendRef` is unset anyway; the ordering makes the intent explicit). */
     suspendLoop?: boolean;
-    /** design/45: the task deliberately suspended at a durable tool gate (capture + abort fired). When set,
-     *  the result is `status:"suspended"` carrying this token/gate — a clean pause, NOT a failure, so it is
-     *  slotted ABOVE the `!final`/aborted branches (slot 8.5: it beats them but yields to a real
-     *  budget/threw failure that happened to coincide). The abort it used sets `final.stopReason="aborted"`
-     *  but does not set `threw`, so it never reaches the `flags.threw` branch. */
-    suspendRef?: {
-        token: import("../checkpoint-store.js").CheckpointToken;
-        /** The non-secret identity twin ({@link import("../checkpoint-store.js").Checkpoint.checkpointId}). */
-        checkpointId?: string;
-        gate: import("../checkpoint-store.js").CheckpointGate;
-        /** RB-439-b: how the paused workspace comes back (`"park_only"` = a non-suspendable target that was
-         *  never actually paused). Echoed on `TaskResult.workspaceRestoreMode`; absent for a process-local
-         *  suspend, which captured no remote workspace. */
-        restoreMode?: "snapshot" | "park_only";
-    };
-    /** design/76 §2.5 (dry-run / shadow) + design/80 D-B (plan-gate): the task deliberately paused at a
-     *  REVIEW-PAUSE gate — `{kind:"needs_review"}` (a profile's dry-run interception produced a predicted
-     *  state-diff a human/judge must REVIEW) OR `{kind:"plan_review"}` (a profile's plan-gate produced a
-     *  proposed PLAN a human must approve/edit/reject). When set, the result is `status:"needs_review"` +
-     *  errorCode `"review.pending"`, carrying this token/gate (keyed off ref-PRESENCE, not `gate.kind`, so it
-     *  serves both review kinds uniformly). It is the DUAL of `suspendRef` but for DIFFERENT semantics (a human
-     *  REVIEW, not a pre-action tool-call APPROVAL), so it has its OWN flag and its OWN assemble slot (8.6,
-     *  between `suspendRef` 8.5 and the aborted branches 9) — **never both set at once** (the commit-side
-     *  discriminant in prepare-task branches on `gate.kind` and sets exactly one). Disjoint from `suspendRef`
-     *  so this branch is reachable: keying status off `suspendRef` alone (reusing it) would report `"suspended"`
-     *  and make this dead code (v4 MAJOR-A). Like `suspendRef`, it used an abort to stop the loop (no `threw`),
-     *  so it never hits the failure branches above. */
-    reviewRef?: {
-        token: import("../checkpoint-store.js").CheckpointToken;
-        checkpointId?: string;
-        gate: import("../checkpoint-store.js").CheckpointGate;
-        /** RB-439-b: the review pause pauses the same workspace the approval pause does — same discriminant. */
-        restoreMode?: "snapshot" | "park_only";
-    };
+    /** The run's ONE committed durable pause (the holder's `pausedRef.current.cause`): the run stopped at a
+     *  gate — an approval or content ask, a resource slice, a platform pause, a plan or dry-run review —
+     *  and a checkpoint is durably committed. It used an abort to stop the loop (`final.stopReason ===
+     *  "aborted"`) but set no `threw`/timeout/turns, so it is slotted ABOVE the `!final`/aborted arms (a
+     *  clean pause, not a failure) and BELOW the real budget/threw failures (a limit that coincided still
+     *  owns the ending). WHICH terminal status it reads (`suspended` / `needs_review`) is the pause's own
+     *  `gate.kind` registry row, not a second flag: the two same-shaped refs that used to split the approval
+     *  family from the review family — and the slot order between them that only ever mattered if both were
+     *  somehow set — are gone with the commit-side routing that fed them. */
+    paused?: PausedCause;
 }
 /**
  * Extract a machine-readable code from a thrown error (e.g. `SessionError.code`, a Node error code).
@@ -236,6 +212,23 @@ export interface ResultFlags {
  * prefer the first specific code over a generic `"unknown"` wrapper.
  */
 export declare function errorCodeOf(err: unknown): string | undefined;
+/**
+ * WHY the run ended — the ONE terminal arbitration ({@link TerminalCause}). First match wins, in the
+ * slot order documented on {@link assembleResult} (a public contract: do not reorder). Every plane
+ * field a result shows (`status`, `errorCode`, `errorMessage`, `blockedReason`, the checkpoint seats)
+ * is projected from the value this returns by {@link terminalProjection}, so a terminal that carries a
+ * token cannot be reported under a status that does not, and a review pause cannot be reported as an
+ * approval pause: the pairing is the cause's shape, not the arbitration's discipline.
+ *
+ * `apiFailure` rides beside the cause rather than inside it on purpose: it is the message's own
+ * provider-failure disclosure, filled only when a provider failure IS the terminal (the same
+ * in-presence rule the usage-window wait hint states for itself), and it is not part of the cause's
+ * public projection.
+ */
+export declare function terminalCauseOf(final: AssistantMessage | undefined, stats: Pick<Stats, "humanReview">, flags: ResultFlags): {
+    terminal: TerminalCause;
+    apiFailure: TaskResult["apiFailure"];
+};
 /**
  * Build the final {@link TaskResult} from the run's terminal state. **The errorCode priority chain is a
  * public contract** (callers `switch` on these strings) — first match wins, in this exact order
@@ -252,12 +245,10 @@ export declare function errorCodeOf(err: unknown): string | undefined;
  *   6. `threw` + conflict→ `"conflict"`
  *   7. `threw` (other)   → `errorCodeOf(threw)`
  *   8. `blockedReason`   → status `"blocked"` (no errorCode)
- *   8.5 `suspendRef`     → status `"suspended"` + checkpointToken/gate (design/45 B4 — a deliberate
- *       durable pause beats the abort it used, but yields to a real budget/threw failure above)
- *   8.6 `reviewRef`     → status `"needs_review"` + `"review.pending"` + checkpointToken/gate (design/76 §2.5
- *       — a dry-run post-prediction REVIEW pause; the DUAL of 8.5, between it and the aborts, same red-line:
- *       a `suspendRef` at 8.5 still wins if both were somehow set, proving slot order — but the commit-side
- *       discriminant guarantees only one is ever set)
+ *   8.5 `paused`         → status by the pause's registry row (`suspended` for an approval / resource
+ *       slice / platform pause, `needs_review` + `"review.pending"` for a plan or dry-run review) +
+ *       checkpointToken/gate (design/45 B4 — a deliberate durable pause beats the abort it used, but
+ *       yields to a real budget/threw failure above)
  *   9. `abortedLive` | stopReason aborted → `"limits.max_walltime_exceeded"` | `"limits.max_turns_exceeded"` | undefined
  *       (audit A-1: hoisted ABOVE no-final — the loop exits cleanly on abort, so `final` may be a
  *       normal message or absent; a plain user interrupt carries NO errorCode — switch on `status`),

package/dist/core/runner/assemble-result.js

@@ -1,5 +1,6 @@
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { extractErrorCode, stripErrorCodePrefix } from "../../brain/errors.js";
+import { terminalProjection } from "./terminal-projection.js";
 const SALVAGE_ELIGIBLE_TERMINALS = new Set([
     "output.degenerate",
     "limits.max_tokens_exceeded",
@@ -40,30 +41,9 @@ function assistantText(msg) {
         .join("");
     return stripThinkTags(text);
 }
-export function assembleResult(spec, sessionId, final, stats, flags) {
-    const taskId = spec.taskId ?? sessionId;
-    const text = final ? assistantText(final) : "";
-    if (!flags.unpricedSpend) {
-        const compactionMicroUsd = stats.compactionMicroUsd ?? 0;
-        const nestedSubagentMicroUsd = stats.nested?.costMicroUsd ?? 0;
-        stats.costBreakdown = {
-            llmRootMicroUsd: Math.max(0, stats.costMicroUsd - compactionMicroUsd),
-            nestedSubagentMicroUsd,
-            memoryConsolidationMicroUsd: 0,
-            compactionMicroUsd,
-        };
-    }
-    let status;
-    const result = text;
-    let errorMessage;
-    let errorCode;
+export function terminalCauseOf(final, stats, flags) {
+    let terminal;
     let apiFailure;
-    let blockedReason;
-    let salvagedOutput;
-    let checkpointToken;
-    let checkpointId;
-    let checkpointGate;
-    let workspaceRestoreMode;
     const haltOwnsAbortedFinal = flags.userHalted === true &&
         final?.stopReason === "aborted" &&
         !flags.abortedLive &&
@@ -71,107 +51,108 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         flags.abortedForTurns !== true;
     const isDegenerate = final?.stopReason === "error" && isDegenerateCutMessage(final);
     if (flags.outputInvalid) {
-        status = "failed";
-        errorCode = "output.invalid";
-        errorMessage = "model did not produce a valid structured output within the retry limit";
+        terminal = { kind: "failed", code: "output.invalid", message: "model did not produce a valid structured output within the retry limit" };
     }
     else if (isDegenerate) {
-        status = "failed";
-        errorCode = "output.degenerate";
-        errorMessage = final?.errorMessage;
+        terminal = { kind: "failed", code: "output.degenerate", ...(final?.errorMessage !== undefined ? { message: final.errorMessage } : {}) };
     }
     else if (flags.budgetHit) {
-        status = "failed";
-        errorCode = flags.budgetAxis === "tokens" ? "limits.max_tokens_exceeded" : "limits.max_cost_exceeded";
         const axisName = flags.budgetAxis === "tokens" ? "limits.maxTokens" : "limits.maxCostUsd";
-        errorMessage =
-            flags.budgetHit === "precall"
+        terminal = {
+            kind: "failed",
+            code: flags.budgetAxis === "tokens" ? "limits.max_tokens_exceeded" : "limits.max_cost_exceeded",
+            message: flags.budgetHit === "precall"
                 ? `the estimated cost of the first call already exceeds ${axisName}; the task was not started`
-                : `cumulative usage exceeded ${axisName}`;
+                : `cumulative usage exceeded ${axisName}`,
+        };
     }
     else if (flags.suspendLoop) {
-        status = "failed";
-        errorCode = "suspend.loop";
-        errorMessage = "task suspended too many times (resume/restart loop) — exceeded the suspend limit";
+        let message = "task suspended too many times (resume/restart loop) — exceeded the suspend limit";
         const gates = stats.humanReview?.gates ?? [];
         if (gates.length > 0 && gates.every((g) => g.decision === "allow")) {
-            errorMessage +=
+            message +=
                 `. Diagnosis: all ${gates.length} recorded gate decision(s) on this run were ALLOW — a gate that keeps ` +
                     `asking combined with an approver that keeps approving consumes the suspend allowance on legitimate ` +
                     `work. Remedies: answer asks at a LIVE onAsk (a synchronous allow parks nothing and consumes no ` +
                     `suspend), keep provably-benign commands inside the read boundary so the classifier auto-allows them, ` +
                     `or raise maxSuspends for genuinely approval-heavy tasks.`;
         }
+        terminal = { kind: "failed", code: "suspend.loop", message };
     }
     else if (flags.threw) {
-        status = "failed";
-        errorMessage = flags.threw instanceof Error ? flags.threw.message : String(flags.threw);
-        errorCode = flags.abortedForTimeout
+        const message = flags.threw instanceof Error ? flags.threw.message : String(flags.threw);
+        const code = flags.abortedForTimeout
             ? "limits.max_walltime_exceeded"
             : flags.abortedForTurns
                 ? "limits.max_turns_exceeded"
                 : flags.conflict
                     ? "conflict"
                     : errorCodeOf(flags.threw);
+        terminal = { kind: "failed", ...(code !== undefined ? { code } : {}), message };
     }
     else if (flags.blockedReason) {
-        status = "blocked";
-        blockedReason = flags.blockedReason;
-    }
-    else if (flags.suspendRef) {
-        status = "suspended";
-        checkpointToken = flags.suspendRef.token;
-        checkpointId = flags.suspendRef.checkpointId;
-        checkpointGate = flags.suspendRef.gate;
-        workspaceRestoreMode = flags.suspendRef.restoreMode;
-    }
-    else if (flags.reviewRef) {
-        status = "needs_review";
-        errorCode = "review.pending";
-        checkpointToken = flags.reviewRef.token;
-        checkpointId = flags.reviewRef.checkpointId;
-        checkpointGate = flags.reviewRef.gate;
-        workspaceRestoreMode = flags.reviewRef.restoreMode;
+        terminal = { kind: "blocked", reason: flags.blockedReason };
+    }
+    else if (flags.paused) {
+        terminal = flags.paused;
     }
     else if ((flags.abortedLive || final?.stopReason === "aborted") && !haltOwnsAbortedFinal) {
-        status = "failed";
-        errorCode = flags.abortedForTimeout ? "limits.max_walltime_exceeded" : flags.abortedForTurns ? "limits.max_turns_exceeded" : undefined;
-        errorMessage = final?.errorMessage ?? (flags.abortedForTurns ? "max turns exceeded" : "run aborted");
+        const code = flags.abortedForTimeout ? "limits.max_walltime_exceeded" : flags.abortedForTurns ? "limits.max_turns_exceeded" : undefined;
+        terminal = { kind: "failed", ...(code !== undefined ? { code } : {}), message: final?.errorMessage ?? (flags.abortedForTurns ? "max turns exceeded" : "run aborted") };
     }
     else if (flags.userHalted === true && (!final || haltOwnsAbortedFinal)) {
-        status = "completed";
+        terminal = { kind: "completed" };
     }
     else if (!final) {
-        status = "failed";
-        errorMessage = "no assistant message produced";
+        terminal = { kind: "failed", message: "no assistant message produced" };
     }
     else if (final.stopReason === "error") {
-        status = "failed";
-        errorMessage = final.errorMessage ?? "model error";
+        let message = final.errorMessage ?? "model error";
+        let code;
         if (final.isApiErrorMessage === true) {
             apiFailure = {
                 ...(final.apiErrorStatus !== undefined ? { status: final.apiErrorStatus } : {}),
                 ...(final.requestId !== undefined ? { requestId: final.requestId } : {}),
             };
         }
-        const lifted = extractErrorCode(errorMessage);
+        const lifted = extractErrorCode(message);
         if (lifted) {
-            errorCode = lifted;
-            errorMessage = stripErrorCodePrefix(errorMessage);
+            code = lifted;
+            message = stripErrorCodePrefix(message);
         }
         else if (flags.gitCoreOverBudget) {
-            errorCode = "irreducible_core_over_budget";
+            code = "irreducible_core_over_budget";
         }
         else if (flags.conflict) {
-            errorCode = "conflict";
+            code = "conflict";
         }
         else {
-            errorCode = "provider.error";
+            code = "provider.error";
         }
+        terminal = { kind: "failed", code, message };
     }
     else {
-        status = "completed";
+        terminal = { kind: "completed" };
     }
+    return { terminal, apiFailure };
+}
+export function assembleResult(spec, sessionId, final, stats, flags) {
+    const taskId = spec.taskId ?? sessionId;
+    const text = final ? assistantText(final) : "";
+    if (!flags.unpricedSpend) {
+        const compactionMicroUsd = stats.compactionMicroUsd ?? 0;
+        const nestedSubagentMicroUsd = stats.nested?.costMicroUsd ?? 0;
+        stats.costBreakdown = {
+            llmRootMicroUsd: Math.max(0, stats.costMicroUsd - compactionMicroUsd),
+            nestedSubagentMicroUsd,
+            memoryConsolidationMicroUsd: 0,
+            compactionMicroUsd,
+        };
+    }
+    const result = text;
+    let salvagedOutput;
+    const { terminal, apiFailure } = terminalCauseOf(final, stats, flags);
+    const { status, errorCode } = terminalProjection(terminal);
     if (errorCode !== undefined && SALVAGE_ELIGIBLE_TERMINALS.has(errorCode)) {
         salvagedOutput = text.trim() || undefined;
     }
@@ -181,5 +162,5 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     if (flags.unpricedSpend)
         delete publicStats.costMicroUsd;
     const stampHaltedByUser = flags.userHalted === true && status !== "suspended" && status !== "needs_review";
-    return { taskId, ...(flags.runId !== undefined ? { runId: flags.runId } : {}), sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, ...(apiFailure !== undefined ? { apiFailure } : {}), ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), checkpointToken, ...(checkpointId !== undefined ? { checkpointId } : {}), checkpointGate, ...(workspaceRestoreMode !== undefined ? { workspaceRestoreMode } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.editedFiles !== undefined && flags.editedFiles.length > 0 ? { editedFiles: flags.editedFiles } : {}), ...(flags.haltedOnUserRejection === true ? { haltedOnUserRejection: true } : {}), ...(stampHaltedByUser ? { haltedByUser: true } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: [...flags.remoteEnvFailures] } : {}), ...(flags.strandedHumanAnswers !== undefined && flags.strandedHumanAnswers.length > 0 ? { strandedHumanAnswers: flags.strandedHumanAnswers } : {}), ...(flags.effectiveReadFace !== undefined ? { effectiveReadFace: flags.effectiveReadFace } : {}), ...(flags.effectiveReadDenyPatterns !== undefined && flags.effectiveReadDenyPatterns.length > 0 ? { effectiveReadDenyPatterns: flags.effectiveReadDenyPatterns } : {}), ...(flags.effectiveMemoryScopes !== undefined ? { effectiveMemoryScopes: flags.effectiveMemoryScopes } : {}), ...(flags.effectiveReasoning !== undefined ? { effectiveReasoning: flags.effectiveReasoning } : {}), stats: publicStats };
+    return { taskId, ...(flags.runId !== undefined ? { runId: flags.runId } : {}), sessionId, terminal, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, ...(apiFailure !== undefined ? { apiFailure } : {}), ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), ...(flags.editedFiles !== undefined && flags.editedFiles.length > 0 ? { editedFiles: flags.editedFiles } : {}), ...(flags.haltedOnUserRejection === true ? { haltedOnUserRejection: true } : {}), ...(stampHaltedByUser ? { haltedByUser: true } : {}), ...(flags.remoteEnvFailures !== undefined && flags.remoteEnvFailures.length > 0 ? { remoteEnvFailures: [...flags.remoteEnvFailures] } : {}), ...(flags.strandedHumanAnswers !== undefined && flags.strandedHumanAnswers.length > 0 ? { strandedHumanAnswers: flags.strandedHumanAnswers } : {}), ...(flags.effectiveReadFace !== undefined ? { effectiveReadFace: flags.effectiveReadFace } : {}), ...(flags.effectiveReadDenyPatterns !== undefined && flags.effectiveReadDenyPatterns.length > 0 ? { effectiveReadDenyPatterns: flags.effectiveReadDenyPatterns } : {}), ...(flags.effectiveMemoryScopes !== undefined ? { effectiveMemoryScopes: flags.effectiveMemoryScopes } : {}), ...(flags.effectiveReasoning !== undefined ? { effectiveReasoning: flags.effectiveReasoning } : {}), stats: publicStats };
 }

package/dist/core/runner/checkpoint-scope.d.ts

@@ -1,7 +1,9 @@
 /**
- * The durable-suspend checkpoint SCOPE vocabulary — the default isolation scope and the ONE derivation of a row's scope —
- * moved whole out of the orchestrator so the wiring-manifest phase (the synthesized durableApproval) and the driver's
- * park-lane mint sites reach DOWN for the same two names. Pure: a constant and a string function over two spec fields.
+ * The durable-suspend checkpoint ROW-IDENTITY vocabulary — the default isolation scope, the ONE derivation of a row's
+ * scope, and the ONE reading of the placement fields' empty string — moved whole out of the orchestrator so the
+ * wiring-manifest phase (the synthesized durableApproval), the park-lane phases (the mint sites and the suspend stamp),
+ * the driver (the restore fold) and runtask (the resume rung) reach DOWN for the same names. Pure: a constant and two
+ * string functions.
  */
 /** design/77 §4.4: the multi-tenant scope used when a durable suspend fires for an IRREVERSIBLE tool in an
  *  unattended deployment that did NOT opt into `durableApproval` (so there is no caller-supplied scope). The
@@ -30,3 +32,13 @@ export declare function checkpointScopeOf(spec: {
     };
     principal?: string;
 }): string;
+/**
+ * rescan C5 — the ONE spelling of the placement fields' empty-string discipline: `""` is absence
+ * wearing clothes (the resume entry's principal-rung posture), and every placement read that must
+ * treat it so — the resume rung's two sides (runtask), the restore fold's seed and the suspend
+ * stamp — goes through THIS helper, so three sites cannot drift into three readings. Deliberately
+ * NOT applied to the live `internals.placementRoot`/`rootSessionId` reads of the RESOLUTION fold:
+ * an empty supplied claim there is an assembly error the execution-env phase's `mintPlacementRootSessionId` refuses
+ * loudly on the factory path, and normalizing it away would silently repair what should be loud.
+ */
+export declare function placementValueOrAbsent(value: string | undefined): string | undefined;

package/dist/core/runner/checkpoint-scope.js

@@ -2,3 +2,6 @@ export const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export function checkpointScopeOf(spec) {
     return spec.durableApproval?.scope || spec.principal || DEFAULT_IRREVERSIBLE_SCOPE;
 }
+export function placementValueOrAbsent(value) {
+    return value || undefined;
+}

package/dist/core/runner/compaction-call-options.d.ts

@@ -3,7 +3,7 @@ import type { MaybeCompactOptions } from "../auto-compaction.js";
 import type { StaleToolResultOffloadOptions, TaskSpec } from "../types.js";
 import type { Context } from "../../internal/llm.js";
 import { type ToolResultStore } from "../tool-result-store.js";
-import type { Prepared } from "./prepare-task.js";
+import type { Prepared } from "./contracts.js";
 /**
  * REF-A2 (car R11) — the maybeCompact call arguments that MUST be assembled identically on all three
  * of runtask's compaction lanes (turn boundary / prompt-too-long recovery / end-of-task).

package/dist/core/runner/content-ask-bindings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The content-ask BINDING vocabulary: the leak bound the routing lane checks against and the one entry shape the
+ * binding table holds. It lived in the question-face phase (which mints the table) while the routing lane was still
+ * orchestrator code; the lane is a phase now, and a phase reaching SIDEWAYS into a sibling for a constant and a type
+ * is the wrong reading — both phases reach DOWN for them here.
+ */
+import type { QuestionAnswer } from "../ask-question.js";
+export declare const CONTENT_ASK_BINDING_CAP = 32;
+/** One gate-routed content-ask outcome, keyed by the call id it was produced for (see the table's own note). */
+export type ContentAskBinding = ({
+    kind: "answered";
+    answer: QuestionAnswer;
+} | {
+    kind: "failed";
+    error: unknown;
+}) & {
+    /** Digest of the exact question batch this outcome belongs to. The call id alone is not enough
+     *  to redeem a binding: it comes from the model/provider and can repeat, so an entry that
+     *  outlived its call (its call was allowed but never executed) could otherwise be handed to a
+     *  LATER call that happens to reuse the id. Matching on the batch as well means an outcome can
+     *  only ever be delivered for the question it was produced for. */
+    questionsHash: string;
+    /** The engine-minted per-delivery identity (see AskQuestionRequest.deliveryId) — carried so a
+     *  stranded-answer disclosure names DELIVERIES, not call ids: call ids can repeat, and a
+     *  disclosure keyed on them would collapse two lost answers into one. */
+    deliveryId: string;
+};

package/dist/core/runner/content-ask-bindings.js

@@ -0,0 +1 @@
+export const CONTENT_ASK_BINDING_CAP = 32;