@sema-agent/core 7.8.0 → 7.9.0

package/dist/core/runner/resume-review-outcome.js

@@ -0,0 +1,88 @@
+import { CheckpointError } from "../checkpoint-store.js";
+import { isGateKind, PAUSE_REGISTRY, resumeGateMatches } from "../pause-registry.js";
+import { sanitizeUntrustedText } from "../untrusted-text.js";
+import { assertOutcomeText, describeSuppliedValue } from "./decide-continuation.js";
+export function resumeReviewOutcome(input) {
+    const { cp, outcome, outcomeGate, wakeMessage } = input;
+    const gateMatch = isGateKind(cp.gate.kind) && resumeGateMatches(cp.gate.kind, outcomeGate);
+    if (!gateMatch) {
+        throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") does not match checkpoint gate "${cp.gate.kind}" — resume serves ${Object.entries(PAUSE_REGISTRY)
+            .filter(([, row]) => !row.terminal)
+            .map(([k, row]) => `${k}/${row.resume}`)
+            .join(", ")}`);
+    }
+    let plainReviewOutcome;
+    if (cp.gate.kind === "plan_review") {
+        const decide = outcome;
+        const decision = decide.decision;
+        const editedPlan = decide.editedPlan;
+        const reason = decide.reason;
+        if (decision !== "approve" && decision !== "edit" && decision !== "reject") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the plan_review domain — a plan review is exactly "approve", "edit" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+        }
+        assertOutcomeText(editedPlan, "editedPlan");
+        assertOutcomeText(reason, "reason");
+        plainReviewOutcome = {
+            gate: "plan_review",
+            decision,
+            ...(editedPlan !== undefined ? { editedPlan } : {}),
+            ...(reason !== undefined ? { reason } : {}),
+        };
+    }
+    else if (cp.gate.kind === "needs_review") {
+        const decide = outcome;
+        const decision = decide.decision;
+        const reason = decide.reason;
+        if (decision !== "approve" && decision !== "reject") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the dry_run_review domain — a dry-run review is exactly "approve" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+        }
+        assertOutcomeText(reason, "reason");
+        plainReviewOutcome = {
+            gate: "dry_run_review",
+            decision,
+            ...(reason !== undefined ? { reason } : {}),
+        };
+    }
+    if (plainReviewOutcome !== undefined) {
+        const reason = plainReviewOutcome.reason;
+        if (plainReviewOutcome.decision === "reject" && reason && sanitizeUntrustedText(reason) !== reason) {
+            throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+        }
+        const capturedPlan = plainReviewOutcome.gate === "plan_review" ? plainReviewOutcome.editedPlan : undefined;
+        if (plainReviewOutcome.decision === "edit" &&
+            capturedPlan &&
+            sanitizeUntrustedText(capturedPlan) !== capturedPlan) {
+            throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
+        }
+        if (cp.reopenReason === "env_failed") {
+            const winner = cp.resolvedOutcome;
+            if (winner === undefined) {
+                throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+            }
+            if (winner.decision !== plainReviewOutcome.decision) {
+                throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${plainReviewOutcome.decision}")`);
+            }
+            if (winner.updatedInput !== capturedPlan) {
+                throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
+            }
+            if (winner.reason !== undefined && winner.reason !== plainReviewOutcome.reason) {
+                throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose reviewer note differs from the recorded one");
+            }
+        }
+    }
+    let plainParkOutcome;
+    if (outcomeGate === "wake") {
+        plainParkOutcome = {
+            gate: "wake",
+            ...(wakeMessage !== undefined ? { message: wakeMessage } : {}),
+        };
+    }
+    else if (outcomeGate === "resource_limit") {
+        const decision = outcome.decision;
+        if (decision !== "continue") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the resource_limit domain — a slice resume is exactly "continue"; refusing pre-CAS, the checkpoint stays pending`);
+        }
+        plainParkOutcome = { gate: "resource_limit", decision };
+    }
+    return { plainReviewOutcome, plainParkOutcome };
+}

package/dist/core/runner/run-harness-handlers.js

@@ -261,7 +261,7 @@ export function createHarnessHandlers(input) {
             toolName: event.toolName,
             ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
             isError: event.isError,
-            ...toolEndBodyFrom(event.result, event.isError, gate, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined),
+            ...toolEndBodyFrom(event.result, event.isError, prepared.structuredProjector, gate, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined),
             ...ident(),
         });
         announceWorkspaceMove();

package/dist/core/runner/runtask.d.ts

@@ -56,6 +56,9 @@ export declare class Runner implements RunnerSelfSeat {
      *  never a wrong destroy. */
     private readonly locallyClaimedTokens;
     private static readonly PARENT_CONSTRAINT_REGISTRY_CAP;
+    /** The lanes' LIVE view of `deps` ({@link RunnerDepsSeat}): a getter, never a captured object, because
+     *  `swapModels` replaces the object and a rung reading after its own await must see the replacement. */
+    private readonly depsSeat;
     constructor(deps: RunnerDeps);
     /** design/73 §1 v1 — fire `RunnerDeps.onTaskOutcome` through the single swallow-guarded chokepoint
      *  ({@link emitTaskOutcome}: mechanical-tier only, throwing sink never breaks the caller). Public so
@@ -227,6 +230,23 @@ export declare class Runner implements RunnerSelfSeat {
      *  authority, so constraint substitution here is outside the enforced threat model (the count check
      *  catches shape MISTAKES, not a untrusted trusted caller). */
     internals?: RunInternals): Promise<TaskStream>;
+    /**
+     * design/393 S3 — the resume decision ladder after admission (E3–E10), driving the eight `resume-*` lanes in
+     * the order the one-function ladder had: the review / park twins, the approval twin and its bindings, the
+     * checkpoint screen, the internals-and-config rungs (whose one window await is taken HERE, where the ladder
+     * took it), then the three async rungs after it — apply, preflight, claim — each entering the next in its own last
+     * continuation, and the post-claim hand-off to the resumed leg. Every rung throws its typed refusal pre-CAS;
+     * the first `return` is the leg's stream.
+     */
+    private resumeLadder;
+    /**
+     * design/393 S3 — the ladder's POST-CLAIM rung (E11), the driver's own: the post-consume hook, the answering
+     * face minted from the decide's answer, the resumed leg's spec (identity continuity, the existing-session
+     * requirement, the stripped pre-aborted preempt signal), the reopen compensation and the execution-record
+     * verb bound to the row, the two post-CAS abort re-checks, and the hand-off to `runTaskStream` with the plain
+     * twin. Entered in the claim rung's last continuation, so its first statement runs on the tick the win was read.
+     */
+    private resumeHandoff;
     /**
      * design/45 resume step: with the harness idle and the branch rewound to the suspension leaf, resolve
      * the gated tool call and close the rest of the suspended batch, all by appending `toolResult`s to the