@sema-agent/core 7.11.2 → 7.12.0

package/dist/core/auto-mode.js

@@ -1,14 +1,17 @@
-import { AUTO_MODE_DEFAULT_FAILURE_THRESHOLD, AUTO_MODE_DEFAULT_TIMEOUT_MS, AUTO_MODE_DENIAL_AUTO_DENY_DEFAULT_MS, AUTO_MODE_DENIAL_LIMIT_DEFAULTS } from "./auto-mode-defaults.js";
-export const AUTO_MODE_UNAVAILABLE_CAUSES = ["error", "timeout", "breaker_open"];
+import { AUTO_MODE_DEFAULT_TIMEOUT_MS, AUTO_MODE_DENIAL_AUTO_DENY_DEFAULT_MS, AUTO_MODE_DENIAL_LIMIT_DEFAULTS } from "./auto-mode-defaults.js";
+export const AUTO_MODE_UNAVAILABLE_CAUSES = ["error", "timeout"];
 const AUTO_MODE_UNAVAILABLE_CAUSE_SET = new Set(AUTO_MODE_UNAVAILABLE_CAUSES);
 export function isAutoModeUnavailableCause(v) {
     return AUTO_MODE_UNAVAILABLE_CAUSE_SET.has(v);
 }
-export const AUTO_MODE_BREAKER_CAUSES = ["error", "timeout", "parse_error"];
-const AUTO_MODE_BREAKER_CAUSE_SET = new Set(AUTO_MODE_BREAKER_CAUSES);
-export function isAutoModeBreakerCause(v) {
-    return AUTO_MODE_BREAKER_CAUSE_SET.has(v);
+export function classifierUnavailableDenyMessage(toolName, cause) {
+    const parenthetical = cause === "timeout" ? " (timed out)" : "";
+    return (`The auto-mode classifier is temporarily unavailable${parenthetical}, so auto mode cannot determine the safety of ${toolName} right now. ` +
+        "Wait a moment and then try this action again. " +
+        "If it keeps failing, continue with other tasks that don't require this action and come back to it later. " +
+        "Note: reading files, searching code, and other read-only operations do not require the classifier and can still be used.");
 }
+export const CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE = "Auto mode could not evaluate this action and is blocking it for safety — the classifier's reply carried no verdict.";
 export function parseAutoModeResponse(text) {
     const rawAnswers = new Set([...text.matchAll(/<block>(yes|no)\b/gi)].map((m) => m[1].toLowerCase()));
     if (rawAnswers.size > 1)
@@ -28,20 +31,6 @@ export function parseAutoModeResponse(text) {
 }
 export function createAutoModeDecider(opts) {
     const timeoutMs = opts.timeoutMs ?? AUTO_MODE_DEFAULT_TIMEOUT_MS;
-    const threshold = Math.max(1, Math.floor(opts.failureThreshold ?? AUTO_MODE_DEFAULT_FAILURE_THRESHOLD));
-    let consecutiveFailures = 0;
-    let open = false;
-    const recordFailure = (cause) => {
-        consecutiveFailures++;
-        if (!open && consecutiveFailures >= threshold) {
-            open = true;
-            try {
-                opts.onBreakerOpen?.({ consecutiveFailures, lastCause: cause });
-            }
-            catch {
-            }
-        }
-    };
     const decide = async (input, signal) => {
         const startedAt = performance.now();
         const verdict = await decideUnreported(input, signal);
@@ -59,14 +48,8 @@ export function createAutoModeDecider(opts) {
         }
         return verdict;
     };
-    return {
-        breakerOpen: () => open,
-        consecutiveFailures: () => consecutiveFailures,
-        decide,
-    };
+    return { decide };
     async function decideUnreported(input, signal) {
-        if (open)
-            return { kind: "unavailable", cause: "breaker_open" };
         let timer;
         const inner = new AbortController();
         const onOuterAbort = () => inner.abort();
@@ -98,21 +81,12 @@ export function createAutoModeDecider(opts) {
                     }
                 });
             });
-            if (open)
-                return { kind: "unavailable", cause: "breaker_open" };
-            const verdict = parseAutoModeResponse(raw);
-            if (verdict.kind === "parse_error")
-                recordFailure("parse_error");
-            else
-                consecutiveFailures = 0;
-            return verdict;
+            return parseAutoModeResponse(raw);
         }
         catch (e) {
             if (signal?.aborted)
                 return { kind: "unavailable", cause: "error" };
-            const timedOut = e instanceof AutoModeTimeout;
-            recordFailure(timedOut ? "timeout" : "error");
-            return { kind: "unavailable", cause: timedOut ? "timeout" : "error" };
+            return { kind: "unavailable", cause: e instanceof AutoModeTimeout ? "timeout" : "error" };
         }
         finally {
             if (timer !== undefined)
@@ -127,27 +101,6 @@ class AutoModeTimeout extends Error {
         super("auto-mode classify timeout");
     }
 }
-export class AutoModeBreakerLedger {
-    cap;
-    trips = new Map();
-    constructor(cap = 1024) {
-        this.cap = cap;
-    }
-    record(sessionId, trip) {
-        if (this.trips.has(sessionId))
-            this.trips.delete(sessionId);
-        this.trips.set(sessionId, trip);
-        while (this.trips.size > this.cap) {
-            const oldest = this.trips.keys().next().value;
-            if (oldest === undefined)
-                break;
-            this.trips.delete(oldest);
-        }
-    }
-    lastTrip(sessionId) {
-        return this.trips.get(sessionId);
-    }
-}
 export function readDenialLimitFallback(v) {
     if (typeof v !== "object" || v === null)
         return undefined;

package/dist/core/checkpoint-store.d.ts

@@ -1123,9 +1123,7 @@ export interface CheckpointState {
          *  suspend leg did. It is a MEMORY of intent, never an authorization: the resuming deployment's
          *  face (`RunnerDeps.autoMode`) and the resuming principal's deny bit (`RuntimeCaps.autoMode`)
          *  are judged afresh on every leg — a bit on the row cannot arm where the redeeming deployment
-         *  would not. Follows the classifier's latch: a leg armed here writes it only while its own breaker
-         *  is untripped and untouched (a session that fell back to non-auto hands nothing forward); a leg
-         *  never armed here carries the memory as is. Absent on older checkpoints and on non-auto tasks
+         *  would not. A leg never armed here carries the memory as is. Absent on older checkpoints and on non-auto tasks
          *  (byte-identical to the pre-bit row); an older worker that ignores it resumes un-armed, the
          *  narrower direction. */
         autoModeRequested?: true;

package/dist/core/gate-fold.js

@@ -128,15 +128,7 @@ export async function runGateFold(pass) {
             pass.decision = { ...pass.decision, probeMandated: true };
         }
     }
-    const breakerKnownOpen = (d) => {
-        try {
-            return d.breakerOpen();
-        }
-        catch {
-            return false;
-        }
-    };
-    if (input.peerMessage === true && pass.decision.action === "allow" && input.autoMode !== undefined && !breakerKnownOpen(input.autoMode.decider)) {
+    if (input.peerMessage === true && pass.decision.action === "allow" && input.autoMode !== undefined) {
         pass.decision = {
             action: "ask",
             message: `tool "${toolName}" sends a message to another agent — routed for classifier review in auto mode`,

package/dist/core/gate-lanes.js

@@ -1,6 +1,6 @@
 import { decisionText, describeThrown } from "./tool-policy.js";
 import { askOriginOf, classifierMayAnswer } from "./ask-origin.js";
-import { denialLimitFallbackMessage, unarmedWindow } from "./auto-mode.js";
+import { CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, classifierUnavailableDenyMessage, denialLimitFallbackMessage, unarmedWindow } from "./auto-mode.js";
 import { inlineUntrusted } from "./untrusted-text.js";
 import { isRuleBehavior } from "./permission-rule-model.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./ask-question.js";
@@ -388,9 +388,17 @@ export async function runGateLanes(pass) {
                     ...(pass.policyRewrite !== undefined ? { updatedInput: pass.policyRewrite } : {}),
                 };
             }
-            else if (verdict.kind === "block") {
-                const reason = verdict.reason ? inlineUntrusted(verdict.reason) : "";
-                const category = verdict.category ? inlineUntrusted(verdict.category) : "";
+            else if (verdict.kind === "unavailable") {
+                pass.decision = {
+                    action: "deny",
+                    message: classifierUnavailableDenyMessage(toolName, verdict.cause),
+                    decisionReason: "classifier",
+                    classifierUnavailable: { cause: verdict.cause },
+                };
+            }
+            else {
+                const reason = verdict.kind === "block" ? (verdict.reason ? inlineUntrusted(verdict.reason) : "") : CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE;
+                const category = verdict.kind === "block" && verdict.category ? inlineUntrusted(verdict.category) : "";
                 const tracked = input.autoMode.denialTracking?.recordBlock();
                 if (tracked?.limitReached === true) {
                     const fallbackAsk = {
@@ -405,15 +413,13 @@ export async function runGateLanes(pass) {
                 else {
                     pass.decision = {
                         action: "deny",
-                        message: `auto-mode classifier blocked this call${reason ? `: ${reason}` : category ? `: [${category}]` : ""}`,
+                        message: verdict.kind === "block" ? `auto-mode classifier blocked this call${reason ? `: ${reason}` : category ? `: [${category}]` : ""}` : reason,
                         decisionReason: "classifier",
                     };
-                    pass.deniedBy = "classifier";
                 }
             }
-            else if (verdict.kind === "unavailable") {
-                pass.decision = { ...pass.decision, classifierUnavailable: { cause: verdict.cause } };
-            }
+            if (pass.decision.action === "deny")
+                pass.deniedBy = "classifier";
         }
         if (input.sandboxAdmission !== undefined &&
             pass.decision.action === "ask" &&

package/dist/core/hooks.d.ts

@@ -411,6 +411,12 @@ export interface PermissionDeniedPayload {
      * settled none.
      */
     gate: GateOutcome;
+    /** #661 (additive): present ⇔ this deny is the auto-mode classifier's UNAVAILABILITY (`deniedBy: "classifier"`
+     *  with the verdict's cause word) — the structured half of the deny text's "the classifier is temporarily
+     *  unavailable" sentence. A classifier BLOCK or parse-failure deny carries no member here. */
+    classifierUnavailable?: {
+        readonly cause: import("./auto-mode.js").AutoModeUnavailableCause;
+    };
     /** {@link HookSeatSignal} — this invocation's own abort signal. On an OBSERVATION seat the deny has
      *  already happened and nothing this callback does can change it, so the signal says exactly one
      *  thing: stop reading, nobody is waiting for your answer any more. */

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

@@ -22,7 +22,7 @@ import type { WorkflowSizeGuideline } from "../../orchestration/workflow-size-gu
 import type { ToolManifestRow } from "../../prompt-assembly/tool-catalog.js";
 import type { CwdRef, ReadFace } from "../../tools/fs/index.js";
 import type { MaterializedA2a } from "../a2a.js";
-import type { CompactionForkContext, MaybeCompactOptions, RapidRefillState } from "../auto-compaction.js";
+import type { CompactionForkContext, CompactionPhaseDurations, MaybeCompactOptions, RapidRefillState } from "../auto-compaction.js";
 import type { AutoModeArmingRecipe } from "../auto-mode-arming.js";
 import type { AutoModeDecider, AutoModeDenialTracker } from "../auto-mode.js";
 import type { CacheBreakDetector, ToolFingerprintInput } from "../cache-break-detector.js";
@@ -1778,14 +1778,6 @@ export interface RunInternals {
      * channel, same posture as every other field here.
      */
     sessionReadStates?: SessionReadFileStates;
-    /**
-     * #616 — the Runner's per-session breaker ledger ({@link import("../auto-mode.js").AutoModeBreakerLedger}):
-     * the arming site's `onBreakerOpen` wrap records a trip here, the wiring-manifest phase of a LATER leg of
-     * the same session reads the most recent one onto `autoMode.breaker`. Always set by the Runner's own
-     * prepare call (overriding any caller value, like `sessionReadStates` beside it); absent on a standalone
-     * prepareTask, where no trip is recorded and none is reported. Trusted internals channel.
-     */
-    autoModeBreakerLedger?: import("../auto-mode.js").AutoModeBreakerLedger;
     onTaskNotification?: (notification: TaskNotificationPayload, 
     /** Injection tier (design/373 — the ladder is LIVE): "next" = the running turn's next boundary
      *  (arrival order, consecutive frames batch); "later" = the run's would-otherwise-stop seat
@@ -2475,6 +2467,46 @@ export interface ManualCompactRef {
     emitMooted?: (reason: string) => void;
     closed?: boolean;
 }
+/**
+ * design/393 S6 — the end-of-task compaction pass's outcome (`Runner.finish`'s return): what the terminal-adoption lane
+ * hands the settle lane, which reads it for the `compacted` frame, the phase-timings frame and the detector reset. Named
+ * once here so the two lanes and the method spell one type.
+ */
+export type EndOfTaskCompaction = {
+    compacted: boolean;
+    tokensBefore?: number;
+    triggerTokens?: number;
+    postTriggerTokens?: number;
+    durationMs?: number;
+    phaseDurations?: CompactionPhaseDurations;
+    firstKeptEntryId?: string;
+    attachedFiles?: Array<{
+        path: string;
+        chars: number;
+        truncated: boolean;
+    }>;
+    modelFallback?: true;
+    fallbackReason?: "window";
+    clampedRatio?: number;
+    clampReason?: "budget" | "tolerance";
+} | undefined;
+/**
+ * design/393 S6 — the notification lane's BINDINGS: the run-notification-lane's own four `let`s as ONE seat (getters
+ * and setters over the lane's variables, never a copy). The identity-wiring lane binds `harness` / `sessionId` /
+ * `ident` the moment `prepared` exists (the lane's closures read them by variable — the routing listener, the park
+ * destination, the injection entry); the leg lane flips `live` in its finally, from which point every notification
+ * parks per session for the next run. One seat, four slots; nothing copies a binding out of it.
+ */
+export interface NotificationLaneBindings {
+    harness: AgentHarness | undefined;
+    sessionId: string | undefined;
+    ident: () => {
+        eventId?: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    live: boolean;
+}
 /** design/144 §2 — the `notify()` bridge: `runLocked` binds `inject` the moment the task-notification lane exists. */
 export interface NotifyRef {
     inject?: (n: TaskNotificationPayload, opts?: {

package/dist/core/runner/denial-limit-arms.d.ts

@@ -32,8 +32,7 @@ export interface InheritedAutoMode {
  * recorded recipe — `rebuildAutoModeDecider` hands back a decider and its arming, nothing live)
  * carries no denial tracker, and an entry with a decider but no tracker would count nothing: the
  * rebuilt classifier could block without bound on the redeemed leg, the exact gap the limit closes.
- * Attach a FRESH tracker (a fresh COUNT is the documented cross-process semantics — the breaker
- * restarts the same way) under the ancestor's recorded BOUNDS tightened by this deployment's own
+ * Attach a FRESH tracker (a fresh COUNT is the documented cross-process semantics) under the ancestor's recorded BOUNDS tightened by this deployment's own
  * (#556, `tightenDenialLimit` — the same rule and the same call the arming fold makes, so the
  * recipe's account of the criteria and the tracker's actual bounds cannot drift). Before #556 the
  * bounds came from this deployment alone, so an ancestor that allowed three consecutive blocks
@@ -84,8 +83,8 @@ export type InheritedAsk = Extract<PermissionResult, {
 }>;
 /** The members of a surviving ask that ride onto the approval request with a COMPUTED value — what the
  *  four request mint stations (the gate's own and the three inherited-lane ones) spread after the seats
- *  they spell themselves: the ask's origin word, its denial-limit fallback and the classifier-unavailable
- *  fact (#616). */
+ *  they spell themselves: the ask's origin word, its denial-limit fallback and a policy-declared
+ *  classifier-unavailable fact (#616; the engine's own fact rides the DENY since #661). */
 export interface AskRequestCarry {
     origin?: AskOrigin;
     denialLimitFallback?: DenialLimitFallback;
@@ -117,18 +116,15 @@ export type InheritedClassifierJudgment<A extends InheritedAsk> =
     kind: "deny";
     result: PermissionResult;
 }
-/** Proceed to the frozen approver with `ask`: the incoming ask unchanged (classifier unavailable,
- *  excluded, or not armed), or — at the bound — the fallback ask minted from it (`mintedHere`).
+/** Proceed to the frozen approver with `ask`: the incoming ask unchanged (classifier excluded or not
+ *  armed), or — at the bound — the fallback ask minted from it (`mintedHere`).
  *  `fallback` is the member riding the ask either way (an incoming one is a deeper ancestor's).
  *  `origin` is the ask's word under the station facts, threaded to the request mint: on the two
  *  unchanged-ask branches it is the SAME read the exclusion judged by (a caller-owned decision with a
  *  stateful accessor cannot answer the exclusion with one word and the card with another); on the
  *  bound branch it is derived from the re-spoken ask this station minted (its own object). */
-/** `ask` is the incoming ask unchanged — EXCEPT on an UNAVAILABLE round, where it is an engine-owned copy
- *  carrying `classifierUnavailable: { cause }` (#616): the fact rides the ASK because the ask is what the
- *  wrapper arms hand back to the gate when the frozen approver answers unavailable (the inherited-unavailable
- *  float), and the gate's own park carry reads the fact off the decision it parks — a side member on this
- *  judgment would have been lost on that route (codex r1). The request mint reads the same object. */
+/** `ask` is the incoming ask unchanged (the caller's own object); an UNAVAILABLE round never reaches this arm —
+ *  it is a `deny` carrying `classifierUnavailable: { cause }` (#661). */
  | {
     kind: "resolve";
     ask: A;
@@ -142,8 +138,9 @@ export type InheritedClassifierJudgment<A extends InheritedAsk> =
  * auto-allow (and the streak resets); `block` below the bound ⇒ deny, the exact verdict the ancestor's
  * gate would have produced; `block` AT the bound ⇒ the ask is re-spoken in the classifier's voice as
  * the fallback (`decisionReason:"classifier"`, `requiresRealApproval`, the member carrying counts +
- * window) for the arm to resolve at the frozen approver; anything else (unavailable / parse error /
- * excluded / no classifier) ⇒ the incoming ask, unchanged. The member may ALREADY be on the incoming
+ * window) for the arm to resolve at the frozen approver; `parse_error` ⇒ the same block path with the CC
+ * parse-failure sentence (counted); `unavailable` ⇒ a DENY that says so, carrying the fact (#661, CC
+ * 2.1.250 form); excluded / no classifier ⇒ the incoming ask, unchanged. The member may ALREADY be on the incoming
  * ask (a deeper ancestor's fallback, minted inside the nested fold — the case the exclusion names):
  * it rides to the approver and the headless arm unchanged, whichever tracker minted it; only a
  * tracker that counted THIS streak is reset by the person's later allow (`mintedHere`).

package/dist/core/runner/denial-limit-arms.js

@@ -1,4 +1,4 @@
-import { createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow } from "../auto-mode.js";
+import { CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, classifierUnavailableDenyMessage, createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow } from "../auto-mode.js";
 import { sanitizeAutoModeArmingRecipe, tightenDenialLimit } from "../auto-mode-arming.js";
 import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted } from "../untrusted-text.js";
@@ -85,19 +85,21 @@ export async function judgeInheritedClassifier(opts) {
         autoMode.denialTracking?.recordAllow();
         return { kind: "allow" };
     }
-    if (verdict.kind !== "block") {
-        const resolved = verdict.kind === "unavailable" ? { ...ask, classifierUnavailable: { cause: verdict.cause } } : ask;
-        return { kind: "resolve", ask: resolved, fallback: ask.denialLimitFallback, mintedHere: false, origin };
+    if (verdict.kind === "unavailable") {
+        return {
+            kind: "deny",
+            result: { action: "deny", message: classifierUnavailableDenyMessage(req.toolName, verdict.cause), decisionReason: "classifier", classifierUnavailable: { cause: verdict.cause } },
+        };
     }
-    const reason = verdict.reason ? inlineUntrusted(verdict.reason) : "";
-    const category = verdict.category ? inlineUntrusted(verdict.category) : "";
+    const reason = verdict.kind === "block" ? (verdict.reason ? inlineUntrusted(verdict.reason) : "") : CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE;
+    const category = verdict.kind === "block" && verdict.category ? inlineUntrusted(verdict.category) : "";
     const tracked = autoMode.denialTracking?.recordBlock();
     if (tracked?.limitReached !== true) {
         return {
             kind: "deny",
             result: {
                 action: "deny",
-                message: `auto-mode classifier blocked ${opts.subject} at an inherited ancestor layer${reason ? `: ${reason}` : category ? `: [${category}]` : ""}`,
+                message: verdict.kind === "block" ? `auto-mode classifier blocked ${opts.subject} at an inherited ancestor layer${reason ? `: ${reason}` : category ? `: [${category}]` : ""}` : `${reason} (${opts.subject}, at an inherited ancestor layer)`,
                 decisionReason: "classifier",
             },
         };

package/dist/core/runner/gate-exit.js

@@ -103,7 +103,15 @@ export async function exitGate(pass) {
         if (pass.deniedBy === undefined)
             throw new Error(`the tool gate refused "${toolName}" without a refusing layer — every deny site attributes itself`);
         const gate = mintGateOutcome({ deniedBy: pass.deniedBy, ...(ledger.settled !== undefined ? { settled: ledger.settled } : {}) });
-        await notifyPermissionDenied({ toolName, input: cloneObserverInput(pass.currentInput), toolCallId, reason: denyReason, gate, ...(input.identity !== undefined ? { identity: input.identity } : {}) });
+        await notifyPermissionDenied({
+            toolName,
+            input: cloneObserverInput(pass.currentInput),
+            toolCallId,
+            reason: denyReason,
+            gate,
+            ...(input.identity !== undefined ? { identity: input.identity } : {}),
+            ...(pass.decision.action === "deny" && pass.decision.classifierUnavailable !== undefined ? { classifierUnavailable: { cause: pass.decision.classifierUnavailable.cause } } : {}),
+        });
         return {
             block: true,
             reason: formatHookFeedback(denyReason, input.reminderMark),

package/dist/core/runner/prepare-caps-and-workflow.d.ts

@@ -49,7 +49,7 @@ export interface PrepareCapsAndWorkflowInput {
     deps: RunnerDeps;
     /** borrowed-readonly — the trusted spawn-side channel; the Workflow mount forwards `rootSessionId`, `placementRoot`,
      *  `onTaskNotification`, `workflowDepth`, and the capture-floor getter reads `memoryCaptureAncestors`. */
-    internals: Pick<RunInternals, "rootSessionId" | "placementRoot" | "onTaskNotification" | "workflowDepth" | "memoryCaptureAncestors" | "workflowParkedResume" | "autoModeBreakerLedger"> | undefined;
+    internals: Pick<RunInternals, "rootSessionId" | "placementRoot" | "onTaskNotification" | "workflowDepth" | "memoryCaptureAncestors" | "workflowParkedResume"> | undefined;
     /** borrowed-readonly — the acquired session; the classifier leg rebuilds its transcript window from `buildContext`. */
     session: Pick<StoredSession, "buildContext">;
     /** borrowed-readonly — the acquired session id (operator-line context, the refusal codes' phase record). */

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -195,11 +195,6 @@ export async function prepareCapsAndWorkflow(input) {
         autoModeDenialTracking = createAutoModeDenialTracker(am.denialLimit);
         autoModeDecider = createAutoModeDecider({
             ...(am.timeoutMs !== undefined ? { timeoutMs: am.timeoutMs } : {}),
-            ...(am.failureThreshold !== undefined ? { failureThreshold: am.failureThreshold } : {}),
-            onBreakerOpen: (info) => {
-                internals?.autoModeBreakerLedger?.record(sessionId, { openedAtMs: Date.now(), lastCause: info.lastCause, failures: info.consecutiveFailures, runId });
-                am.onBreakerOpen?.(info);
-            },
             onClassified: (info) => emitTrace(deps.tracer, () => ({
                 kind: "auto_mode.classified",
                 version: 1,

package/dist/core/runner/prepare-suspend-saga.d.ts

@@ -17,7 +17,6 @@
  * the boundary parks and the park closure key off `saga`'s presence, so the orchestrator grows no branch.
  */
 import type { AgentHarness, ExecutionEnv } from "../../internal/harness.js";
-import type { AutoModeDecider } from "../auto-mode.js";
 import type { OwnOrgAdmissionVerdict } from "../memory-admission.js";
 import type { RemoteExecutionEnv, SnapshotId } from "../remote-env.js";
 import type { CheckpointStore, SerializedCheckpointState } from "../checkpoint-store.js";
@@ -128,7 +127,6 @@ export interface PrepareSuspendSagaInput {
     /** borrowed-readonly — the auto-mode intent (seat ∨ live ∨ seed), carried while the latch is healthy. */
     autoModeIntent: boolean;
     /** borrowed-readonly — the auto-mode decider, or undefined (the latch-health reading only). */
-    autoModeDecider: AutoModeDecider | undefined;
     /** borrowed-readonly — the inherited admitted org scopes, or undefined (copied onto the row). */
     inheritedAdmittedOrgScopes: readonly string[] | undefined;
     /** borrowed-readonly — this leg's OWN org verdict seat; `current` is read at mint time. Not written here. */

package/dist/core/runner/prepare-suspend-saga.js

@@ -77,16 +77,8 @@ export async function compensateUnparkedPause(remoteEnv, snapshotId, io) {
 function stampPlacementRootSessionId(placementRootResolved) {
     return placementValueOrAbsent(placementRootResolved);
 }
-function autoModeLatchHealthy(d) {
-    try {
-        return d.breakerOpen() !== true && typeof d.consecutiveFailures === "function" && d.consecutiveFailures() === 0;
-    }
-    catch {
-        return false;
-    }
-}
 export function prepareSuspendSaga(input) {
-    const { gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, autoModeDecider, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
+    const { gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
     if (!gateMachineryActive)
         return { saga: undefined };
     const inFlightSpendMicroUsd = () => {
@@ -140,7 +132,7 @@ export function prepareSuspendSaga(input) {
             const constraintDigest = (inheritedParentConstraints?.length ?? 0) > 0
                 ? constraintChainDigest(constraintChain)
                 : seedInheritedGate?.constraintDigest;
-            const autoModeIntentCarried = autoModeIntent && (autoModeDecider === undefined || autoModeLatchHealthy(autoModeDecider));
+            const autoModeIntentCarried = autoModeIntent;
             return inheritedAncestorRules !== undefined ||
                 inheritedShellGate !== undefined ||
                 autoModeIntentCarried ||

package/dist/core/runner/prepare-task.js

@@ -678,7 +678,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             });
         }
         const { askLane } = prepareAskLane({ gateMachineryActive, abortController, effectivePolicy, budgetSnapshot, handsCwdRef, tools, inheritedUnavailableAsks, inheritedAskGrants, onAsk, humanReviewRef, now, ruleOffersOf, askSourceIdentity, riskAxesOf, autoModeDenialTracking, spec, deps, sessionId, runId, hooks, hookTimeoutMs, notifyOwnHookCrash });
-        const { saga } = prepareSuspendSaga({ gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, autoModeDecider, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter });
+        const { saga } = prepareSuspendSaga({ gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter });
         const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, pausedRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
         const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedBash, shellGatedMonitor, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef });
         prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, gateOutcomes, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedBash, shellGatedMonitor, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });

package/dist/core/runner/prepare-wiring-manifest.d.ts

@@ -46,7 +46,7 @@ export interface PrepareWiringManifestInput {
     deps: RunnerDeps;
     /** borrowed-readonly — the trusted spawn-side channel: `questionFaceStripped`, `isDelegatedChild`, `onTaskNotification`,
      *  `peerSelfRef`, `explicitAgentName` (the drain), `insideFork` / `agentName` / `parentToolCallId` (the identity). */
-    internals: Pick<RunInternals, "questionFaceStripped" | "isDelegatedChild" | "onTaskNotification" | "peerSelfRef" | "explicitAgentName" | "insideFork" | "agentName" | "parentToolCallId" | "autoModeBreakerLedger"> | undefined;
+    internals: Pick<RunInternals, "questionFaceStripped" | "isDelegatedChild" | "onTaskNotification" | "peerSelfRef" | "explicitAgentName" | "insideFork" | "agentName" | "parentToolCallId"> | undefined;
     /** borrowed-readonly — the resume leg, or undefined (the manifest's leg derivation reads presence only). */
     resume: Pick<PrepareResume, "seed"> | undefined;
     /** borrowed-readonly — the acquired session id. */

package/dist/core/runner/prepare-wiring-manifest.js

@@ -199,14 +199,7 @@ export function prepareWiringManifest(input) {
         memoryAdmissionWired: deps.memoryScopeAdmission !== undefined,
         retentionPolicyWired: deps.retentionPolicy !== undefined,
         ...(modelGateManifest !== undefined ? { modelGate: modelGateManifest } : {}),
-        autoMode: {
-            armed: autoModeArmReason === "armed",
-            reason: autoModeArmReason,
-            ...(() => {
-                const trip = internals?.autoModeBreakerLedger?.lastTrip(sessionId);
-                return trip !== undefined ? { breaker: trip } : {};
-            })(),
-        },
+        autoMode: { armed: autoModeArmReason === "armed", reason: autoModeArmReason },
         mcp: mcpManifestEntries(lockedPreflight.mcp, mcp.statuses),
         tools: toolRoster,
     });

package/dist/core/runner/run-attachment-seats.d.ts

@@ -1,6 +1,6 @@
 import type { TaskSpec } from "../types.js";
 import type { Prepared, ResumeRun, RunnerDepsSeat, RunState } from "./contracts.js";
-export interface RunAttachmentSeatsInput {
+export interface RunAttachmentSeatsInput<R> {
     /** borrowed-readonly — the task spec: the attachments config and the `finalVerification` opt-in. */
     spec: TaskSpec;
     /** borrowed-mutable — the leg's prepared seat: `announcedListingsRef` is seeded; the session, the listing faces,
@@ -13,8 +13,10 @@ export interface RunAttachmentSeatsInput {
     rs: RunState;
     /** borrowed-readonly — the Runner's deployment deps, read once for `probeInstructionSources`. */
     runner: RunnerDepsSeat;
+    /** borrowed-readonly — the lanes after this one, entered in this lane's last continuation (the seats it wrote are on `rs`). */
+    next: (seats: RunAttachmentSeatsResult) => Promise<R>;
 }
 /** Nothing comes back: the lane's products are the `counters` / `attach` groups it wrote on the borrowed run state. */
 export interface RunAttachmentSeatsResult {
 }
-export declare function runAttachmentSeats(input: RunAttachmentSeatsInput): Promise<RunAttachmentSeatsResult>;
+export declare function runAttachmentSeats<R>(input: RunAttachmentSeatsInput<R>): Promise<R>;

package/dist/core/runner/run-attachment-seats.js

@@ -3,7 +3,7 @@ import { stripGitStatusUnits } from "./git-status-frame.js";
 import { SKILLS_LISTING_PROBE_HEADER } from "./synthetic-tools.js";
 import { AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, agentListingDeltaHeader, agentListingInitialHeader, createAttachmentState, replayAnnouncedListing, replayAnnouncedModels } from "./turn-attachments.js";
 export async function runAttachmentSeats(input) {
-    const { spec, prepared, resume, rs, runner } = input;
+    const { spec, prepared, resume, rs, runner, next } = input;
     rs.counters.wroteThisRun = false;
     rs.counters.finalVerifyInjections = 0;
     rs.counters.groundingSignalPreR9 = false;
@@ -183,5 +183,5 @@ export async function runAttachmentSeats(input) {
         }
     }
     rs.attach.attachmentsInjected = 0;
-    return {};
+    return await next({});
 }

package/dist/core/runner/run-identity-wiring.d.ts

@@ -1,20 +1,9 @@
-/**
- * design/393 S5 — the run body's IDENTITY WIRING (R1), verbatim from `Runner.runLocked`, the first thing after
- * `prepared` exists: the notification lane's bindings (harness, session anchor, identity mint), the backstop
- * carrier's immediate seats, the event-identity mint (`ident`) and the run's canonical task id, the wiring-manifest
- * frame and the roster-delta subscription, the delegation-lifecycle spawn station and its owed-terminal carrier,
- * the manual-compact mooted channel, the harness sinks for undrained engine notes / user inputs / consumed
- * engine notes, the notify / capture-opt-out bridges, the spawner's injector hand-back, the idle-parked
- * notification redelivery at turn open, the loop latch and the live-task handle publication, and the run's
- * usage counters. Every push here happens before the run's first model/tool interaction, as it did.
- */
-import { type AgentHarness } from "../../internal/harness.js";
 import type { PeerInboundChainRef } from "../../agents/peer-admission.js";
 import { type PendingSessionNotifications, type SystemInjectionPriority, type TaskNotificationPayload } from "../task-notification.js";
 import type { PushQueue } from "../push-queue.js";
 import type { TaskEvent, TaskSpec } from "../types.js";
 import type { Stats } from "./assemble-result.js";
-import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, NotifyRef, Prepared, RunInternals, RunnerDepsSeat, TaskIdRef } from "./contracts.js";
+import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, NotificationLaneBindings, NotifyRef, Prepared, RunInternals, RunnerDepsSeat, TaskIdRef } from "./contracts.js";
 export interface RunIdentityWiringInput {
     /** borrowed-readonly — the task spec: the task id and the memory / notification seats it names. */
     spec: TaskSpec;
@@ -38,7 +27,7 @@ export interface RunIdentityWiringInput {
     notifyRef: NotifyRef | undefined;
     /** borrowed-mutable — the capture opt-out bridge: `flip` is bound here when a memory session mounted. */
     captureOptOutRef: CaptureOptOutRef | undefined;
-    /** borrowed-readonly — the notification lane's ONE injection entry (the driver's, until the lane itself moves). */
+    /** borrowed-readonly — the notification lane's ONE injection entry (the R0 lane's). */
     injectTaskNotification: (notification: TaskNotificationPayload, opts?: {
         priority?: SystemInjectionPriority;
     }) => Promise<"queued" | "parked" | "dropped_duplicate">;
@@ -46,26 +35,10 @@ export interface RunIdentityWiringInput {
     deliveredAtTurnOpen: Set<string>;
     /** borrowed-mutable — design/176: the peer inbound chain, overwritten by each consumed peer-class payload. */
     peerInboundChainRef: PeerInboundChainRef;
-    /** borrowed-mutable — the driver's notification-lane bindings, a VIEW over its `let`s (never a copy): this lane binds
-     *  the harness, the session anchor and the identity mint the lane's closures read, and reads the anchor back in
-     *  the undrained-notes sink. */
-    notificationLane: {
-        harness: AgentHarness | undefined;
-        sessionId: string | undefined;
-        ident: () => {
-            eventId?: string;
-            parentToolCallId?: string;
-            sourceTaskId?: string;
-        };
-    };
-    /** borrowed-mutable — the driver's held agent_end account (backlog #389), a view over its `let`: the undrained-inputs
-     *  sink writes it when the run committed a durable park; the driver's tail reads it. */
-    undrainedUserAtEnd: {
-        current: {
-            steer: number;
-            followUp: number;
-        } | undefined;
-    };
+    /** borrowed-mutable — the notification lane's bindings seat (its own `let`s behind getters / setters, never a copy):
+     *  this lane binds the harness, the session anchor and the identity mint the lane's closures read, and reads the
+     *  anchor back in the undrained-notes sink. */
+    notificationLane: NotificationLaneBindings;
     /** borrowed-mutable — the Runner's per-session parked-notification store: drained at turn open, re-pended on failure. */
     pendingSessionNotifications: PendingSessionNotifications;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onDelegationLifecycle`, `onNotice`). */
@@ -92,5 +65,13 @@ export interface RunIdentityWiringResult {
     };
     /** This leg's usage counters, zeroed here; the harness-handlers lane is their writer from the first turn on. */
     stats: Stats;
+    /** backlog #389 — the held agent_end account, a READ FACE over this lane's own `let` (the undrained-inputs sink writes it
+     *  when the run committed a durable park); the terminal-adoption lane settles it minus what the park carried. */
+    undrainedUserAtEnd: {
+        readonly current: {
+            steer: number;
+            followUp: number;
+        } | undefined;
+    };
 }
 export declare function runIdentityWiring(input: RunIdentityWiringInput): RunIdentityWiringResult;