@sema-agent/core 7.12.0 → 7.13.0

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

@@ -652,6 +652,24 @@ export interface Prepared {
     callIssuedAtRef: {
         current?: number;
     };
+    /** #677 — was the run's WORK cut by a stop? Two observation points, one record, read by the answer-settled
+     *  verdict (`answerSettled`) beside the harness's own undrained-input account:
+     *  - `continuation` — the loop decided to CONTINUE past its last assistant turn and the abort caught it
+     *    before that continuation dispatched. Written by the loop-trace sink from the loop's own steps: a
+     *    `continue` step (a drained steer / follow-up, a truncated-output or thinking-only or degenerate-output
+     *    nudge, a next tool turn) sets it; the terminal step clears it unless the loop exited at its
+     *    pre-dispatch abort guard (`aborted_before_stream`) — the one exit where `final` is still the PREVIOUS
+     *    turn's message. A clean "stop" the loop itself had decided was not the end is not a settled answer.
+     *  - `abortedBeforeTurnEnd` — the run's abort was already in force when a turn ENDED (written by the
+     *    `turn_end` handler before the turns cap fires its own abort). The ruling's line is the last
+     *    `turn_end`: a stop that landed before it landed on work — even when the brain ignored the signal
+     *    and delivered a full "stop" answer through it (the loop then ends at its own decision, so the
+     *    continuation bit never sets); a stop that landed after it landed on the tail.
+     *  Always present; both false on a run nothing stopped. */
+    workCutRef: {
+        continuation: boolean;
+        abortedBeforeTurnEnd: boolean;
+    };
     /** RB-458 — records the FIRST brain call this run's outer guardrail gave up on (see
      *  {@link import("../../brain/timeout.js").withBrainCallGuardrail}). Always present; `timedOut`
      *  stays absent unless the guardrail fired. The run loop reads it AFTER the loop settles and gives
@@ -2332,13 +2350,11 @@ export interface TurnBoundaryDeps {
     drainManualCompact: (outcome: CompactOutcome) => void;
     runnerHooks: {
         onError: RunnerDeps["onError"];
-        seamCCompactionOptions: (prepared: Prepared) => Pick<MaybeCompactOptions, "summaryProvider" | "onCompaction" | "maxConsecutiveProviderReuse" | "consecutiveProviderReuse"> | undefined;
-        compactionHookOptions: (spec: TaskSpec, sessionId: string, trigger: "auto" | "manual" | "forced") => Pick<MaybeCompactOptions, "trigger" | "preCompact" | "postCompact">;
-        recordCompactionReuse: (prepared: Prepared, comp: {
-            compacted: boolean;
-            reused?: boolean;
-        }) => void;
     };
+    /** The Runner's deployment deps, read LIVE ({@link RunnerDepsSeat}): the compaction seams (compaction-seams.ts) the
+     *  boundary's compaction pass reaches down for read the summary provider, the hooks slot and the error sink through it
+     *  on every pass — the three Runner methods that used to sit on `runnerHooks` as delegates (design/393 S7). */
+    runner: RunnerDepsSeat;
 }
 /** design/157 B15 尾件 — R5(harness 事件处理器族)的依赖包。全部为 runLocked 内声明顺序早于
  *  工厂调用点的 const 稳定引用 + 三个 runLocked 形参;this 面(deps.onError)经 runnerHooks 打包
@@ -2423,6 +2439,28 @@ export interface RunnerSelfSeat {
     /** Streaming form of {@link RunnerSelfSeat.resume}: the pre-CAS guards and the CAS run first, then the live stream is returned. */
     resumeStream(token: CheckpointToken, outcome: ResumeOutcome, taskConfig: ResumeTaskConfig, internals?: RunInternals): Promise<TaskStream>;
 }
+/**
+ * design/393 S7 (#675) — the orchestrator's entry (`prepareTask`, prepare-task.ts) as ONE contract: the notification lane's
+ * `prepareTask` seat names it, and the orchestrator pins its own declaration against it (`PrepareTaskIsTheContract`), so a
+ * signature change reds at the declaration — not at the driver's hand-in, and not as a seat spelled a second time. It lives
+ * on the floor because a lane may not name the orchestrator (docs/LAYERING.json: layer 4 sits above the lanes). Positional,
+ * exactly as the entry is declared — the seat carries the orchestrator's function itself, not a lane Input.
+ */
+export type PrepareTaskFn = (spec: TaskSpec, deps: RunnerDeps, sessions: SessionStore, resume?: PrepareResume, internals?: RunInternals, runnerSelf?: RunnerSelfSeat, runIdSink?: {
+    runId?: string;
+}) => Promise<Prepared>;
+/**
+ * design/393 S7 (#670) — the Result of an INSTALLING phase: a lane whose every product is installed on a seat it borrowed
+ * (the harness's stop gate and recovery chain, the run state's counter groups, the stream's result setter, the claimed
+ * row's registries) hands nothing back, and says so by extending this marker. The marker is machine-read by gate:phase-api
+ * (design/238 R-1's third clause): a Result with no members MUST extend it, a Result with members MAY NOT, and no Result
+ * inherits anything else — so an empty Result is a stated fact about the phase, never an interface someone forgot to
+ * fill, and a phase that starts handing a product back must drop the declaration in the same edit. Six lanes carry it:
+ * the attachment seats, the stop gate, the recovery lanes, the settle and teardown (run-), the preflight and the claim
+ * (resume-).
+ */
+export interface InstallingPhaseResult {
+}
 /** The live-task handle `runLocked` publishes once the harness exists (design/47): the harness + abort
  *  controller, the loop-liveness latch (`ended` flips when the single `harness.prompt` settles; `userInterrupted`
  *  / `userHalted` are the interrupt and halt verbs' attribution seats), the run's reminder mark, its session and

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

@@ -2,7 +2,7 @@ import { CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, classifierUnavailableDenyMessage
 import { sanitizeAutoModeArmingRecipe, tightenDenialLimit } from "../auto-mode-arming.js";
 import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted } from "../untrusted-text.js";
-import { askOriginOf, classifierMayAnswer } from "../ask-origin.js";
+import { askOriginOf, classifierMayAnswer, probeMandatedAsk } from "../ask-origin.js";
 export function attachRebuiltDenialTrackers(entries, denialLimit) {
     if (entries === undefined)
         return undefined;
@@ -76,8 +76,9 @@ export function inheritedAskCarry(judged, liveApprover, tracker) {
 export async function judgeInheritedClassifier(opts) {
     const { autoMode, ask, req } = opts;
     const origin = askOriginOf(ask, INHERITED_STATION_FACTS);
-    if (autoMode === undefined || !classifierMayAnswer(origin))
+    if (autoMode === undefined || !classifierMayAnswer(origin) || probeMandatedAsk(ask)) {
         return { kind: "resolve", ask, fallback: ask.denialLimitFallback, mintedHere: false, origin };
+    }
     const verdict = await autoMode.decider
         .decide({ req, ...(ask.message !== undefined ? { askMessage: ask.message } : {}) }, opts.signal)
         .catch(() => ({ kind: "unavailable", cause: "error" }));

package/dist/core/runner/permission-rule-lanes.d.ts

@@ -26,7 +26,8 @@
  * silence the ungated-write warning for deployments that wired no policy at all.
  */
 import type { AskRuleEvidence, ToolCallRequest } from "../tool-policy.js";
-import { persistedRuleMandateOf, type OrgGateVerdict, type PersistedRuleAnswer, type PersistedRuleHit, type PersistedRuleUnreadable } from "../hooks.js";
+import { persistedRuleMandateOf } from "../ask-origin.js";
+import { type OrgGateVerdict, type PersistedRuleAnswer, type PersistedRuleHit, type PersistedRuleUnreadable } from "../hooks.js";
 import type { PersistedRule, PersistedRuleVerdict, RuleOffer, SegmentCoverage } from "../permission-rule-model.js";
 import { type OrgRuleResolution } from "../permission-rule-org.js";
 import type { PermissionRuleStoreProvider } from "../permission-rule-provider.js";

package/dist/core/runner/permission-rule-lanes.js

@@ -1,4 +1,5 @@
-import { persistedRuleMandateOf } from "../hooks.js";
+import { persistedRuleMandateOf } from "../ask-origin.js";
+import {} from "../hooks.js";
 import { adjudicatePersistedPathRules, adjudicatePersistedRules, ruleToolGrammarOf, segmentCoverageOf, suggestRulesForCommand } from "../permission-rule-model.js";
 import { isAbsolutePathForm } from "../../tools/fs/safety.js";
 import { effectivePathTargetOf } from "../effective-path-target.js";

package/dist/core/runner/prepare-policy-chain.js

@@ -10,6 +10,7 @@ import { RETIRED_TOOL_NAMES } from "../tool-name-aliases.js";
 import { NAMESPACED_NAME_SHAPES, protocolOf } from "../protocol-table.js";
 import { emitTrace } from "../trace.js";
 import { createActiveSkillScopePolicy } from "./active-skill-scope.js";
+import { probeMandatedAsk } from "../ask-origin.js";
 import { headlessDenyAtFold, headlessDenyAtRecheck, inheritedAskCarry, judgeInheritedClassifier, lateAskSettlementObserver, settleDenialLimitFallback } from "./denial-limit-arms.js";
 import { askGrantShapeOf } from "./inherited-ask-grants.js";
 import { createPermissionRuleLanes, inheritedAskRuleEvidence, createRuleOffersOf } from "./permission-rule-lanes.js";
@@ -374,7 +375,7 @@ export async function preparePolicyChain(input) {
                     if (judged.kind === "deny")
                         return judged.result;
                     const { ask: inheritedAsk, fallback, mintedHere } = judged;
-                    if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName)) {
+                    if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName) && !probeMandatedAsk(inheritedAsk)) {
                         recordAncestorSandboxAdmission(creq.toolCallId, creq.toolName);
                         return { action: "allow" };
                     }
@@ -454,7 +455,7 @@ export async function preparePolicyChain(input) {
                     if (judged.kind === "deny")
                         return judged.result;
                     const { ask: inheritedAsk, fallback, mintedHere } = judged;
-                    if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName)) {
+                    if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName) && !probeMandatedAsk(inheritedAsk)) {
                         recordAncestorSandboxAdmission(creq.toolCallId, creq.toolName);
                         return decision.updatedInput !== undefined ? { action: "allow", updatedInput: decision.updatedInput } : { action: "allow" };
                     }

package/dist/core/runner/prepare-protocol-tools.js

@@ -3,12 +3,17 @@ import { materializeMcpTools } from "../mcp.js";
 import { materializeA2aTools } from "../a2a.js";
 import { deliverEngineNotice } from "../types.js";
 import { RosterBuilder } from "../tool-roster.js";
+import { TOOL_WIRE_NAME_MAX_CHARS } from "../tool-face.js";
 import { REFRESH_MCP_TOOLS_TOOL_NAME, toolFace } from "../tool-catalog-entries.js";
 import { MCP_NAMESPACE, A2A_NAMESPACE } from "../protocol-table.js";
 import { mintNamespacePrefix } from "../protocol-naming.js";
 import { applyMcpToolFaces } from "./tool-face-overlay.js";
 export async function prepareProtocolTools(input) {
     const { lockedPreflight, spec, deps, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, abortController, rollback } = input;
+    const overPeer = (lockedPreflight.mcp ?? []).find((s) => s.name.length > TOOL_WIRE_NAME_MAX_CHARS);
+    if (overPeer !== undefined) {
+        throw Object.assign(new Error(`MCP server name ${JSON.stringify(overPeer.name.slice(0, 40) + "…")} is ${overPeer.name.length} characters; a peer rides every roster row of its tools and the roster's bound on a name is ${TOOL_WIRE_NAME_MAX_CHARS}.`), { code: "config.tool_name_too_long" });
+    }
     const mcp = lockedPreflight.mcp?.length
         ? await materializeMcpTools(lockedPreflight.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer, { reminderMark, counts: reminderDisclosureCounts }, mcpRevocationWiring(deps, runId))
         : { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], refresh: async () => [], dispose: async () => { } };

package/dist/core/runner/prepare-safety-scan.js

@@ -1,7 +1,6 @@
 import { NAMESPACED_NAME_SHAPES } from "../protocol-table.js";
 import { engineCardTypes, handBandEffects } from "../tool-registry.js";
-import { TOOL_CONTRACT_MAX_CHARS, TOOL_WIRE_NAME_MAX_CHARS } from "../tool-face.js";
-import { callerCardIdOf, offendingResultCard, schemaKeyBoundProblem } from "../tool-roster.js";
+import { callerCardIdOf, offendingResultCard, rosterMemberBoundProblem, schemaKeyBoundProblem } from "../tool-roster.js";
 import { toolFaceProblem } from "./tool-face-overlay.js";
 import { OFFLOAD_TOOL_NAME } from "../tool-result-store.js";
 import { PRESENT_PLAN_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME } from "../present-plan-tool.js";
@@ -16,23 +15,19 @@ export function prepareSafetyScan(input) {
     const axisExplicitNegatives = new Map();
     const reversibilityProbes = new Map();
     for (const t of spec.tools ?? []) {
-        if (t.name.length > TOOL_WIRE_NAME_MAX_CHARS) {
-            const e = new Error(`Tool name "${t.name.slice(0, 40)}…" is invalid: ${t.name.length} characters, the roster's bound is ${TOOL_WIRE_NAME_MAX_CHARS}.`);
-            e.code = "config.tool_name_too_long";
-            throw e;
-        }
-        for (const alias of t.aliases ?? []) {
-            if (alias.length > TOOL_WIRE_NAME_MAX_CHARS) {
-                const e = new Error(`Tool alias "${alias.slice(0, 40)}…" (of "${t.name}") is invalid: ${alias.length} characters, the roster's bound is ${TOOL_WIRE_NAME_MAX_CHARS}.`);
-                e.code = "config.tool_name_too_long";
+        {
+            const bound = rosterMemberBoundProblem({
+                name: t.name,
+                aliases: t.aliases,
+                ...(t.contract !== undefined ? { contractId: t.contract.contractId, implementationRevision: t.contract.implementationRevision } : {}),
+                ...(typeof t.modelGate === "string" ? { modelGate: t.modelGate } : {}),
+            });
+            if (bound !== undefined) {
+                const e = new Error(`Tool "${t.name.slice(0, 40)}" cannot ride a roster row: ${bound.message}.`);
+                e.code = bound.code;
                 throw e;
             }
         }
-        if (t.contract !== undefined && (t.contract.contractId.length > TOOL_CONTRACT_MAX_CHARS || t.contract.implementationRevision.length > TOOL_CONTRACT_MAX_CHARS)) {
-            const e = new Error(`Tool "${t.name}" declares a contract member over ${TOOL_CONTRACT_MAX_CHARS} characters (contractId ${t.contract.contractId.length}, implementationRevision ${t.contract.implementationRevision.length}) — the roster's bound.`);
-            e.code = "config.tool_contract_too_long";
-            throw e;
-        }
         {
             const keyProblem = schemaKeyBoundProblem(t.parameters);
             if (keyProblem !== undefined) {

package/dist/core/runner/prepare-task.d.ts

@@ -8,7 +8,7 @@ export { mcpManifestEntries } from "./prepare-wiring-manifest.js";
 export { __resetMaterializeEnvAnnouncements } from "./prepare-tool-disclosure-mount.js";
 export { fileHistoryFilesystemIdentity, resolveFileHistoryScope } from "./prepare-file-history.js";
 import type { RunnerSelfSeat } from "./contracts.js";
-import type { Prepared, PrepareResume, RunInternals } from "./contracts.js";
+import type { Prepared, PrepareResume, PrepareTaskFn, RunInternals } from "./contracts.js";
 export type { FileHistoryBoundarySeat, InheritedGate, Prepared, PreparedMicroCompact, PrepareResume, ResolvedWorkspace, RunInternals, UsageGovernance } from "./contracts.js";
 import type { ExecutionEnv } from "../../internal/harness.js";
 import type { RunnerDeps, TaskSpec } from "../types.js";
@@ -114,3 +114,11 @@ runnerSelf?: RunnerSelfSeat,
 runIdSink?: {
     runId?: string;
 }): Promise<Prepared>;
+/** design/393 S7 (#675) — the entry IS the contract the notification lane's seat names ({@link PrepareTaskFn}, contracts.ts):
+ *  a signature change reds HERE, at the declaration, as `false` failing the `true` bound. IDENTITY, not assignability (review
+ *  round 1): the parameter tuple (arity, optionality, each type) and the return type must be the SAME type in both directions —
+ *  one-way `extends` let a dropped trailing parameter, an added optional one or a narrowed return slip through. Type-level only —
+ *  nothing is emitted. */
+type Holds<T extends true> = T;
+type Same<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+export type PrepareTaskIsTheContract = Holds<Same<Parameters<typeof prepareTask>, Parameters<PrepareTaskFn>>> & Holds<Same<ReturnType<typeof prepareTask>, ReturnType<PrepareTaskFn>>> & Holds<Same<ThisParameterType<typeof prepareTask>, ThisParameterType<PrepareTaskFn>>> & Holds<Same<typeof prepareTask, PrepareTaskFn>>;

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")
@@ -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/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,5 +1,5 @@
 import type { TaskSpec } from "../types.js";
-import type { Prepared, ResumeRun, RunnerDepsSeat, RunState } from "./contracts.js";
+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;
@@ -17,6 +17,6 @@ export interface RunAttachmentSeatsInput<R> {
     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<R>(input: RunAttachmentSeatsInput<R>): Promise<R>;

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

@@ -73,5 +73,12 @@ export interface RunIdentityWiringResult {
             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

@@ -41,7 +41,9 @@ export function runIdentityWiring(input) {
     };
     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 = counts;
             return;
@@ -81,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, undrainedUserAtEnd: { get current() { return undrainedUserAtEnd; } } };
+    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

@@ -5,7 +5,10 @@
  * 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 tail captures the abort facts; the catch
+ * 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.
@@ -79,11 +82,10 @@ export interface RunLegInput<R> {
     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 one home of
-     *  why it is a seat and not a captured object is {@link RunnerDepsSeat}. */
+    /** 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 Runner's application of the resumed decision (its private method, as a delegate). */
-    applyResumeDecision: (prepared: Prepared, resume: ResumeRun, emit: (e: TaskEvent) => void, emitCommitted: (entryId: string, role: "user" | "assistant" | "toolResult", toolCallId?: string) => void, onResolvedToolSuccess?: (toolName: string, details: unknown) => void, onExecuteStart?: (toolCallId: string) => void) => Promise<void>;
     /** borrowed-readonly — the terminal adoption, entered in this lane's last continuation with the leg's facts. */
     next: (leg: RunLegResult) => Promise<R>;
 }