@sema-agent/core 7.11.2 → 7.13.0

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

@@ -429,6 +429,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const rosterSeat = new ToolRosterDeltaSeat();
         const { mcp, a2a, rebuildHarnessToolsRef, contentOriginWrapRef, toolCallGateArmedRef } = await prepareProtocolTools({ lockedPreflight, spec, deps, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, abortController, rollback });
         const callIssuedAtRef = {};
+        const workCutRef = { continuation: false, abortedBeforeTurnEnd: false };
         const memoryWriteGateRef = {};
         const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGateRef, firstPartyOffload, roster, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark, reminderDisclosureCounts, ...(trackFileEdit !== undefined ? { trackFileEdit } : {}), onFileEdited: noteFileEdited, ...(restoredFilePaths.length > 0 ? { restoredFilePaths } : {}) };
         const handsReadFace = handsEnabled ? await prepareHandsMount(handsReadFaceInput) : resolveHandsLessReadFace(handsReadFaceInput);
@@ -617,6 +618,10 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             },
             ...(spec.resilience !== undefined ? { resilience: spec.resilience } : {}),
             loopTrace: (step) => {
+                if (step.kind === "continue")
+                    workCutRef.continuation = true;
+                else
+                    workCutRef.continuation = workCutRef.continuation && step.reason === "aborted_before_stream";
                 if (step.kind !== "continue")
                     return;
                 if (step.reason === "next_turn" || step.reason === "steer_injected" || step.reason === "follow_up_injected")
@@ -678,7 +683,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 });
@@ -686,7 +691,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const preparedHolder = {};
         const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, readTaskFile, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, readDenyAdditionsNormalized, preparedHolder });
         await onceLedger.settle(session, announcedListingsRef);
-        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         rollback.commit();
         const prepared = buildPrepared();
         preparedHolder.current = prepared;

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/resume-claim.d.ts

@@ -9,7 +9,7 @@
  * — the post-consume hook fires on the tick the win was read — and returns what that rung returns.
  */
 import { type Checkpoint, type CheckpointStore, type CheckpointToken } from "../checkpoint-store.js";
-import type { InheritedGate, ResumeRun } from "./contracts.js";
+import type { InheritedGate, InstallingPhaseResult, ResumeRun } from "./contracts.js";
 export interface ResumeClaimInput<R> {
     /** borrowed-readonly — the checkpoint token being claimed. */
     token: CheckpointToken;
@@ -27,6 +27,6 @@ export interface ResumeClaimInput<R> {
     next: (claimed: ResumeClaimResult) => Promise<R>;
 }
 /** The claim's completion is its whole result: a lost CAS throws, so reaching `next` IS the win. */
-export interface ResumeClaimResult {
+export interface ResumeClaimResult extends InstallingPhaseResult {
 }
 export declare function resumeClaim<R>(input: ResumeClaimInput<R>): Promise<R>;

package/dist/core/runner/resume-preflight.d.ts

@@ -10,7 +10,7 @@
  * returns what that rung returns.
  */
 import { type Checkpoint, type CheckpointStore, type CheckpointToken } from "../checkpoint-store.js";
-import type { InheritedGate, RunnerDepsSeat, SuspendReap } from "./contracts.js";
+import type { InheritedGate, InstallingPhaseResult, RunnerDepsSeat, SuspendReap } from "./contracts.js";
 export interface ResumePreflightInput<R> {
     /** borrowed-readonly — the checkpoint token (handed to the deployment and to the settling CAS). */
     token: CheckpointToken;
@@ -35,6 +35,6 @@ export interface ResumePreflightInput<R> {
     next: (screened: ResumePreflightResult) => Promise<R>;
 }
 /** The preflight's completion is its whole result: every refusal throws, so reaching `next` IS the fact. */
-export interface ResumePreflightResult {
+export interface ResumePreflightResult extends InstallingPhaseResult {
 }
 export declare function resumePreflight<R>(input: ResumePreflightInput<R>): Promise<R>;

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 {
+import type { InstallingPhaseResult, Prepared, ResumeRun, RunnerDepsSeat, RunState } from "./contracts.js";
+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 interface RunAttachmentSeatsResult extends InstallingPhaseResult {
 }
-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-git-lane.d.ts

@@ -52,7 +52,7 @@ export interface RunGitLaneInput {
     runner: RunnerDepsSeat;
 }
 export interface RunGitLaneResult {
-    /** The parked-mirror flush — awaited at the serialization points (the owed-frame retry here; prompt settle in the driver). */
+    /** The parked-mirror flush — awaited at the serialization points: the `turn_boundary` subscription here is the regular station (the final boundary of a gracefully ending run included); the leg's post-prompt call is the fallback for a terminal that skipped it. */
     flushGitMirror: () => Promise<void>;
     /** The owed-frame retry's `turn_boundary` subscription; the driver's teardown releases it first. */
     unsubGitRetry: () => void;

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

@@ -281,6 +281,8 @@ export function createHarnessHandlers(input) {
     };
     const onTurnEnd = () => {
         stats.turns += 1;
+        if (prepared.abortController.signal.aborted)
+            prepared.workCutRef.abortedBeforeTurnEnd = true;
         const stopExtra = rs.turn.turnStopReason !== undefined ? { stopReason: rs.turn.turnStopReason } : {};
         queue.push(rs.turn.turnUsage
             ? { type: "turn_end", usage: rs.turn.turnUsage, ...(rs.turn.turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() }

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,20 @@ 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;
+    };
+    /** #677 — did the run END with a person's steer / follow-up still pending (queued, or drained at the final boundary and
+     *  never served)? A READ FACE over this lane's own `let`, written by the same undrained-inputs sink on BOTH its arms
+     *  (park or not): the terminal-adoption lane folds it into the answer-settled verdict — a "stop" answer the person had
+     *  already asked to continue past is not a settled answer, so a stop that cut that continuation is a stop on work. */
+    userInputLostAtEnd: {
+        readonly current: boolean;
+    };
 }
 export declare function runIdentityWiring(input: RunIdentityWiringInput): RunIdentityWiringResult;

package/dist/core/runner/run-identity-wiring.js

@@ -3,7 +3,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedupKey } from "../task-notification.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
 export function runIdentityWiring(input) {
-    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, undrainedUserAtEnd, pendingSessionNotifications, runner } = input;
+    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
     notificationLane.harness = prepared.harness;
     notificationLane.sessionId = prepared.sessionId;
     if (taskIdRef)
@@ -40,9 +40,12 @@ export function runIdentityWiring(input) {
             pendingSessionNotifications.pend(notificationLane.sessionId, p);
     };
     prepared.harness.engineInjectionsHeld = () => prepared.batchHaltRef.current !== undefined;
+    let undrainedUserAtEnd;
+    let userInputLostAtEnd = false;
     prepared.harness.onUndrainedUserInputs = (counts) => {
+        userInputLostAtEnd = counts.steer + counts.followUp > 0;
         if (prepared.pausedRef.current !== undefined) {
-            undrainedUserAtEnd.current = counts;
+            undrainedUserAtEnd = counts;
             return;
         }
         for (const notice of undrainedUserInputNotices(counts, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
@@ -80,5 +83,5 @@ export function runIdentityWiring(input) {
     const loopLatch = { ended: false, userInterrupted: false, userHalted: false };
     onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity });
     const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
-    return { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats };
+    return { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, undrainedUserAtEnd: { get current() { return undrainedUserAtEnd; } }, userInputLostAtEnd: { get current() { return userInputLostAtEnd; } } };
 }

package/dist/core/runner/run-leg.d.ts

@@ -0,0 +1,108 @@
+/**
+ * design/393 S6 — the run body's LEG (R13), verbatim from `Runner.runLocked`: the one `harness.prompt` of the leg and
+ * everything that decides whether it is issued. Two legs behind one try / catch / finally: the RESUME leg (the walltime
+ * and governance-window entrance claims, the gated decision's application, the exhaustion arms, the continuation prompt's
+ * assembly — orphaned background tasks, the git frame, the parked steer queue and the wake message each under its own trust
+ * framing and redelivery screen — and the prompt itself) and the OBJECTIVE leg (the UserPromptSubmit screen, the git
+ * frame's primary delivery, the first-frame listings, the pre-call budget / token / entry-governance gates, the image
+ * conversion, the objective's human-input frame and the prompt itself). The resumed decision's application
+ * (`applyResumeDecision`) and the gated call's resolver (`resolvePendingCall` — the post-CAS belts, the execution record)
+ * are the lane's own module-private functions since design/393 S7, verbatim from the Runner's private methods: the resume
+ * leg is their one caller, and a sibling file would be a lane-to-lane reach (the S6 legs' reading). The tail captures the abort facts; the catch
+ * re-throws the resume-equivalent env failures after a bounded teardown and adopts everything else as the leg's throw;
+ * the finally releases the timer, the diagnostics, the signal, the content-ask bindings, flips the notification lane
+ * and releases the four subscriptions in their order.
+ *
+ * Async (twenty first-level awaits, the same awaits at the same positions). It ends by entering the terminal adoption
+ * (`next`) in its LAST continuation — the adoption's first read sits on the tick the finally ran on, as it did in the
+ * one-function body — and returns what it returns. The two legs stay ONE function on purpose: splitting them into two
+ * async functions (the design's "internal split") costs a microtask on the leg → tail edge, and the tail's first reads
+ * there — `abortController.signal.aborted`, `loopLatch.userInterrupted` — are host-mutable attribution facts a late read
+ * would mis-sign (the adversarial r2 HIGH-1 finding recorded on them); the forwarded-frame depth ratchet measured the
+ * extra hop (58 → 59) when the split was tried.
+ */
+import type { AssistantMessage } from "../../internal/llm.js";
+import { type ActorAssertion } from "../checkpoint-store.js";
+import type { PushQueue } from "../push-queue.js";
+import { type TaskEvent, type TaskSpec } from "../types.js";
+import { type WriteFamily } from "./turn-attachments.js";
+import type { NotificationLaneBindings, Prepared, ResumeRun, RunnerDepsSeat, RunState } from "./contracts.js";
+export interface RunLegInput<R> {
+    /** borrowed-readonly — the task spec: the objective, the images, the hooks slot, the principal, the task id. */
+    spec: TaskSpec;
+    /** borrowed-mutable — the run's event queue: the human-input frames, the git echo frames, the listing echo frames. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — the leg's prepared seat: the harness is prompted, the blocked / git / listing refs written, the abort controller aborted and the signal released in the finally. */
+    prepared: Prepared;
+    /** borrowed-readonly — the resume plan when this leg resumes a checkpoint: chooses the resume leg; its delivery bits are written. */
+    resume: ResumeRun | undefined;
+    /** borrowed-mutable — the run's mutable state: the limit flags and the platform terminal are written by the entrance gates. */
+    rs: RunState;
+    /** borrowed-readonly — the API-boundary attribution snapshot of the objective's actor (the objective leg's speaker envelope). */
+    entryActor: ActorAssertion | undefined;
+    /** borrowed-readonly — the effective walltime window (undefined = unbounded): `<= 0` refuses the first turn. */
+    effectiveTimeoutMs: number | undefined;
+    /** borrowed-mutable — the hard walltime timer: claimed (`fired`) and cleared by the exhausted arms and the finally. */
+    timeout: {
+        fired: boolean;
+        clear: () => void;
+    };
+    /** borrowed-readonly — the content push (the resumed batch's frames ride it with the leg's identity). */
+    pushContent: (e: TaskEvent) => void;
+    /** borrowed-readonly — the run's event-identity mint. */
+    ident: () => {
+        eventId: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    /** borrowed-readonly — the `message_committed` mint (the resumed batch's re-applied tool results). */
+    emitCommitted: (entryId: string, role: "user" | "assistant" | "toolResult", toolCallId?: string) => void;
+    /** borrowed-readonly — the write-family resolver (the resume-executed gated write's attachment anchor). */
+    writeFamilyOf: (name: string) => WriteFamily | undefined;
+    /** borrowed-mutable — the observed tool-start ids: the resume-executed gated call registers itself here. */
+    startedToolCallIds: Set<string>;
+    /** borrowed-readonly — the harness-handlers lane's workspace-move announcer (the approved `cd`'s frame). */
+    announceWorkspaceMove: () => void;
+    /** borrowed-readonly — the brain-sinks composition the leg's prompt runs under. */
+    withBrainSinks: <T>(fn: () => Promise<T>) => Promise<T>;
+    /** borrowed-readonly — the git lane's parked-mirror flush, settled after the prompt (single-turn legs reach no boundary). */
+    flushGitMirror: () => Promise<void>;
+    /** borrowed-mutable — the loop-liveness latch: `ended` flips when the prompt settles (or a no-prompt / throw arm is taken); `userInterrupted` is snapshotted. */
+    loopLatch: {
+        ended: boolean;
+        readonly userInterrupted: boolean;
+    };
+    /** borrowed-mutable — the notification lane's bindings seat: `live` flips false in the finally (every later notification parks). */
+    notificationLane: NotificationLaneBindings;
+    /** borrowed-readonly — the notification lane's subscription release, called in the finally right after the flip. */
+    unsubscribeTaskNotifications: () => void;
+    /** borrowed-readonly — the git lane's owed-frame retry release, called in the finally first of the three. */
+    unsubGitRetry: () => void;
+    /** borrowed-readonly — the git lane's boundary-handler release, called second. */
+    unsubBoundary: () => void;
+    /** borrowed-readonly — the git lane's harness-event release, called third. */
+    unsub: () => void;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `hooks`, `onNotice`, `allowImageUrl`; the resumed
+     *  decision's resolver files its execution record's word through `onNotice` too); the one home of why it is a seat and not a
+     *  captured object is {@link RunnerDepsSeat}. */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the terminal adoption, entered in this lane's last continuation with the leg's facts. */
+    next: (leg: RunLegResult) => Promise<R>;
+}
+/** The leg's facts — what the terminal adoption and the settle read. */
+export interface RunLegResult {
+    /** The final assistant message; undefined on every no-prompt arm (blocked, refused, exhausted). */
+    final: AssistantMessage | undefined;
+    /** What the leg threw (undefined on a clean end); the terminal adoption may lift a typed cause over it. */
+    threw: unknown;
+    /** The live-abort flag, captured before the finally's unconditional release-abort. */
+    abortedLive: boolean;
+    /** The snapshot of `loopLatch.userInterrupted`, taken with `abortedLive`. */
+    userInterruptedLive: boolean;
+    /** design/174: the answered-but-never-collected deliveries the finally settled. */
+    strandedHumanAnswers: ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
+}
+export declare function runLeg<R>(input: RunLegInput<R>): Promise<R>;