@claudexor/orchestrator 3.19.0 → 3.22.0

package/dist/orchestrator.js

@@ -2,10 +2,12 @@ import { applyWorkEnvelope, promptWithPointers as renderPromptWithPointers, thre
 import { requestRefusalFailure } from "./runTerminalResults.js";
 import { delegationBeltFor } from "./delegationBelt.js";
 import { bindProcessingAdmission, processingAttemptCostEvidence, processingAdmissionForLease, updateProcessingStreamHold, ProcessingBudgetAdmissionError, } from "./processing-dispatch.js";
-import { cancelledCandidatesResult, emptyCandidateResult, failedCandidatesResult, } from "./candidateTerminals.js";
+import { cancelledCandidatesResult, emptyCandidateResult, failedCandidatesResult, failAfterCandidates, } from "./candidateTerminals.js";
 import { existsSync } from "node:fs";
-import { effectiveAuthPreference, observeNativeSessionEvent, resumeSessionForProfile, rotateSpecOnTypedLimit, } from "./credential-profiles.js";
-import { AdmissionProfileProbes, OrchestratorCredentials, reviewerProfileResolver, rotatedSpecInLaneHome, } from "./orchestrator-credentials.js";
+import { effectiveAuthPreference, observeNativeSessionEvent, resumeSessionForProfile, } from "./credential-profiles.js";
+import { AdmissionProfileProbes, OrchestratorCredentials, reviewerProfileResolver, } from "./orchestrator-credentials.js";
+import { continuityWorkspace, resumableOf, resumableTerminal, } from "./continuity-terminal.js";
+import { openContinuity } from "./continue-from.js";
 import { accountPoolRows } from "./account-pool.js";
 import { writeRunTelemetryArtifact } from "./runTelemetryWriter.js";
 import { buildFileBackedSynthesisInput, materializeWinnerOutputs, stageFileBackedContext, writeCandidateAttemptArtifacts, } from "./candidateOutputs.js";
@@ -13,6 +15,7 @@ import { processAttemptUsage } from "./attemptUsage.js";
 import { captureDirectoryCandidate, directoryHasOutput, directoryCandidateStable, observeDirectoryPaths, publishDirectoryCandidate, } from "./directoryCandidate.js";
 import { appliedAttemptFacts, assertDelegatedEvidence, isMutatingAccess, outerBoundaryNotice, scopedHarnessHome, } from "./delegatedHome.js";
 import * as AC from "./attemptUsageCost.js";
+import * as custody from "./continuation-custody.js";
 import { candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, unanimousDeclaredFailure, } from "./candidateEvidence.js";
 import { capabilityIntents } from "@claudexor/gateway";
 import { reviewCandidateRuns, resolveEngineReview, unreviewedCandidateEvidence, evaluateUnreviewedConvergence, } from "./candidateReview.js";
@@ -22,10 +25,9 @@ import { runPlannerAttempt as executePlannerAttempt, plannerAttemptSummary, } fr
 import { HarnessRunSpec, MAX_COUNCIL_MEMBERS_DEFAULT, ModeKind as ModeKindSchema, QuotaSnapshot as QuotaSnapshotSchema, isBlocking, makeOutcomeFacts, reviewAllowsApply, workStateVetoes, strictifyOutputSchema, estimateEffectiveAuthRoute, } from "@claudexor/schema";
 import { globalConfigDir, loadConfig } from "@claudexor/config";
 import { prepareRoutedProcessing, processingCostEvidence, prepareReviewerProcessing, } from "./processing-routing.js";
-import { acceptedTryOutput, AccessProfileIncompatibleError, AnswerAssembly, CLAUDEXOR_BROWSER_ARTIFACT_SUBDIR, countsAsAgentProgress, HarnessUnavailableError, summarizeDiffPaths as diffStats, withInactivityWatchdog, } from "@claudexor/core";
+import { acceptedTryOutput, AccessProfileIncompatibleError, CLAUDEXOR_BROWSER_ARTIFACT_SUBDIR, countsAsAgentProgress, HarnessUnavailableError, summarizeDiffPaths as diffStats, withInactivityWatchdog, } from "@claudexor/core";
 import { assertRouteModelsAllowed, runModelGovernedRoute } from "./modelGovernance.js";
 import { authModeForCredentialRoute, authModeForPreference, authRouteEvidenceFor, } from "./auth-route-classification.js";
-import { governRouteEffort } from "./effortGovernance.js";
 import { isFullAccess, RequestRequirementsResolver } from "./requestRequirements.js";
 import { activateDelegationParent } from "./delegation-parent-activation.js";
 import { writeRoutingFailureTerminal } from "./routing-failure.js";
@@ -41,7 +43,7 @@ import { cancelledResult, declaredFailure, failTerminally, guardAnnouncedRun, wr
 import { budgetFailureRecord, classifyBudgetFailure } from "./budgetFailure.js";
 import { finalizeStructuredOutput } from "./structuredOutput.js";
 import { admitRun } from "./runAdmission.js";
-import { dropDeltaPastBudget, emitPlanProgress, emitTransientExhausted, emitTransientRetryPlan, observeReadonlySpend, recordAdapterThrow, } from "./laneStreamEvents.js";
+import { dropDeltaPastBudget, emitPlanProgress, emitTransientExhausted, observeReadonlySpend, recordAdapterThrow, } from "./laneStreamEvents.js";
 import { promptWithEngineConstraints, sleep, redactHarnessEvent, harnessEventPayload, safeErrorMessage, renderSummary, observeBudgetSignals, rotateOnStall, recordCleanAttemptMetrics, envInheritance, transientRetryPolicy, reviewerTimeoutMs, harnessInactivityTimeoutMs, observeAuthSwitch, emitPrimaryDivergence, emitPoolDegraded, deliveryRefusalFailure, winnerNeedsHuman, writeRaceDeliveryDecision, } from "./runSupport.js";
 import { candidateStatusInRouteContext, resolveReadOnlyRouteContext, } from "./routeContext.js";
 import { resolveAutoReviewerPanel, resolveExplicitReviewerPanel } from "./reviewerPanel.js";
@@ -55,7 +57,8 @@ import { newAttemptOutputMarkers } from "./attemptOutputMarkers.js";
 import * as delegateFailure from "./delegationFailure.js";
 import * as secretDiff from "./secretDiff.js";
 import { dominantHarnessFailureCategory, harnessFailureNextActions } from "./harnessFailure.js";
-import { finalizeAttempt, readOnlyNoSuccessTerminal, resolveWorkReportEnvelope, unrecoveredToolErrorFailure, unwrapWorkReportEnvelope, webEvidenceFailure, } from "./attemptFinalize.js";
+import { finalizeAttempt, readOnlyNoSuccessTerminal, unrecoveredToolErrorFailure, webEvidenceFailure, } from "./attemptFinalize.js";
+import { resolveWorkReportEnvelope, unwrapWorkReportEnvelope, } from "./workReportEnvelope.js";
 import { buildContinuationPacket, decideContinuation, synthesizeContinuationRequest, } from "./continuation.js";
 import { interactionChannelFor } from "./interaction.js";
 import { liveAttempt } from "./live-input.js";
@@ -73,8 +76,6 @@ import { billingKnowledgeForAuthRoute, attemptUsageCostSettlement, BudgetLedger,
 import { readTextSafe, appendLine, assertNoInlineSecretValues, hashJson, newId, noProjectRepoRoot, redactSecrets, safeInvoke, sha256, userConfigDir, } from "@claudexor/util";
 const LABELS = "ABCDEFGHIJ".split("");
 const NO_PROJECT_ROOT = noProjectRepoRoot();
-/** Default wait for one interactive answer before a benign decline. */
-const DEFAULT_INTERACTION_TIMEOUT_MS = 900_000;
 export class Orchestrator {
     deps;
     gateway;
@@ -210,7 +211,7 @@ export class Orchestrator {
         if (this.deps.reviewers)
             return this.deps.reviewers;
         if (this.deps.reviewerPanel && this.deps.reviewerPanel.length > 0) {
-            return this.resolveExplicitReviewerPanel(cwd, this.deps.reviewerPanel, runAuthPreference);
+            return this.resolveExplicitReviewerPanel(cwd, this.deps.reviewerPanel, runAuthPreference, onIgnoredSetting);
         }
         return resolveAutoReviewerPanel({
             cwd,
@@ -232,7 +233,7 @@ export class Orchestrator {
         if (input.review === false)
             return { reviewers: [] };
         try {
-            // Auto-panel dropped knobs (reviewerEfforts) → ignored-settings channel (QA-070):
+            // Reviewer knobs a panel omitted or dropped → ignored-settings channel (QA-070):
             const warn = (d) => void log.emit("review.preflight", { ignored_settings: [d] });
             const config = this.config(input.repoRoot).global;
             const reviewers = await this.resolveReviewers(input.repoRoot, input.authPreference, warn);
@@ -274,13 +275,14 @@ export class Orchestrator {
             };
         }
     }
-    async resolveExplicitReviewerPanel(cwd, panel, runAuthPreference) {
+    async resolveExplicitReviewerPanel(cwd, panel, runAuthPreference, onIgnoredSetting) {
         return resolveExplicitReviewerPanel({
             cwd,
             registry: this.deps.registry,
             harnessSettings: this.config(cwd)?.global.harnesses ?? {},
             authPreferenceFor: (id) => this.authPreferenceForHarness(cwd, id, runAuthPreference),
             resolveReviewerProfile: reviewerProfileResolver(this.credentials, cwd),
+            onIgnoredSetting,
         }, panel);
     }
     authPreferenceForHarness(repoRoot, harnessId, runAuthPreference) {
@@ -368,6 +370,8 @@ export class Orchestrator {
         quotaAbsences: () => this.deps.quotaAbsences?.() ?? [],
         credentialUnusable: () => this.deps.credentialUnusable?.() ?? [],
         recordCredentialUnusable: (obs) => this.deps.recordCredentialUnusable?.(obs),
+        credentialObserverFactory: () => this.deps.credentialObserverFactory,
+        credentialEvidence: () => this.deps.credentialEvidence,
         preProgressRefusals: () => this.deps.preProgressRefusals,
         authPreferenceForHarness: (repoRoot, harnessId, runPreference) => this.authPreferenceForHarness(repoRoot, harnessId, runPreference),
     });
@@ -657,7 +661,6 @@ export class Orchestrator {
                         requiresFullAccess: manifest.capability_profile.mcp_injection_requires_full_access,
                         fullAccess: isFullAccess(requiredAccess),
                     }),
-                    effortLevels: manifest.capabilities.effort_levels,
                     knownModels: manifest.capabilities.known_models,
                     modelInventory: manifest.capabilities,
                     // A selected profile's credential_kind IS the route (round-18 #2);
@@ -817,7 +820,7 @@ export class Orchestrator {
         // settles clean), so a schema run keeps its interaction channel — since
         // the daemon always arms one, the refusal was denying claude every
         // daemon/CLI structured-output run. The WorkReport side_tool envelope
-        // stays interactive-gated separately (attemptFinalize) as a deliberate
+        // stays interactive-gated separately (workReportEnvelope) as a deliberate
         // scope choice; the caller schema itself rides regardless.
         if (input.outputSchema !== undefined && input.outputSchema !== null) {
             const incapable = out.filter((lane) => !lane.supportsJsonSchemaOutput);
@@ -1139,16 +1142,14 @@ export class Orchestrator {
         // per-harness map, which beats the per-harness settings default. There is
         // no run-global model.
         const model = overrideModel ?? contract.routing_models[routed.adapter.id] ?? s?.defaultModel ?? null;
-        // Effort disclosure (INV-105) against the harness's advertised ladder. This
-        // gate only DISCLOSES an unplaceable level; the clamp belongs to the adapter,
-        // which resolves against the catalog for the profile env the child runs in
-        // (the manifest here is the DEFAULT account's — see effortGovernance.ts). The
-        // contract's FROZEN per-lane effort (QA-035) wins so Exact Retry replays it
-        // without re-reading settings; `effortHint`/settings apply only to an unfrozen lane.
-        const governed = governRouteEffort(contract.routing_efforts[routed.adapter.id] ?? effortHint ?? s?.effort ?? null, { id: routed.adapter.id, ...routed });
-        const effort = governed.effort;
-        if (governed.ignored)
-            ignored.push(governed.ignored);
+        // The effort PREFERENCE travels to the route unchanged (INV-105): discovery
+        // describes the DEFAULT account, so only the final route may resolve it — a
+        // knob adapter against the catalog of the profile env its child runs in, the
+        // engine as `omitted` for a route without a knob — and that one resolution is
+        // what the receipt and the disclosure record. The contract's FROZEN per-lane
+        // effort (QA-035) wins so Exact Retry replays it without re-reading settings;
+        // `effortHint`/settings apply only to an unfrozen lane.
+        const effort = contract.routing_efforts[routed.adapter.id] ?? effortHint ?? s?.effort ?? null;
         return {
             model,
             effort,
@@ -1222,6 +1223,7 @@ export class Orchestrator {
                 processing,
                 processingAdmission,
                 physicalDispatchStarted,
+                credentialObserverFactory: this.deps.credentialObserverFactory,
                 billingVerificationForProfile: (profile) => this.credentials.selectedProfileBillingVerification(profile),
                 paidFallback: this.config(runInput.repoRoot).global.routing.paid_fallback,
             });
@@ -1382,17 +1384,17 @@ export class Orchestrator {
         let applied = appliedNow();
         const attemptStartedMs = Date.now();
         const budgetSignalState = { quotaPressureDisclosed: false };
-        const triedProfiles = new Set(); // W5.4 failover: each profile at most once
         let cost = 0;
         let costEstimated = false;
         let harnessErrored = false;
+        let streamBudgetDenied = false;
         let processingRefusal = null;
         let poolExhausted = null; // A5: typed pool-exhausted refusal
         const deltaFlood = { count: 0, disclosed: false }; // W-C4 per-attempt delta budget
         // QA-024: emit the belt-failure disclosure event at most once per attempt.
         let beltFailureDisclosed = false;
         const errors = [];
-        let answer = new AnswerAssembly();
+        let answer = new secretDiff.CountedAnswerAssembly();
         const retryPolicy = transientRetryPolicy(this.config(contract.repo.root));
         // QA-024: the delegation belt is the ONLY engine-owned extra MCP server
         // injected into an agent lane (the browser MCP rides its own field), so its
@@ -1413,28 +1415,31 @@ export class Orchestrator {
             onAbort();
         else
             signal?.addEventListener("abort", onAbort, { once: true });
+        let continuity;
+        ({ continuity, spec } = await openContinuity(this.continuityDeps(adapter, routed, contract, attemptId, paths, runInput, log, {
+            envelope,
+            harnessHome,
+            workOrder: prompt,
+            firstPrompt: spec.prompt,
+        }), { spec, continuation: runInput?.continuation, store, telemetry }));
         try {
             for (let nativeTry = 0; !signal?.aborted; nativeTry += 1) {
                 // A3 per-try isolation: neither output nor progress markers leak across tries.
                 if (nativeTry > 0) {
-                    answer = new AnswerAssembly();
+                    answer = new secretDiff.CountedAnswerAssembly();
                     telemetry.outputMarkers = newAttemptOutputMarkers();
                 }
                 const clearFileBackedContext = stageFileBackedContext(envelope.worktree_path, fileBackedContext);
                 const runSpec = nativeTry === 0
                     ? spec
                     : HarnessRunSpec.parse({ ...spec, session_id: newId("ses"), extra: { ...spec.extra } });
-                // Per-TRY abort controller: the inactivity watchdog aborts THIS try's
-                // stream (killing the process group through the existing abort
-                // plumbing) without touching the run-level cancel signal, so a timeout
-                // and a user cancel stay distinguishable. Recreated per
-                // nativeTry — a transient retry must get a LIVE signal, not the
-                // previous try's already-aborted composite.
+                // The watchdog aborts only this try; run cancellation also prevents successors.
                 const attemptAbort = new AbortController();
                 runSpec.extra["abortSignal"] = signal
                     ? AbortSignal.any([signal, attemptAbort.signal])
                     : attemptAbort.signal;
                 activeSessionId = runSpec.session_id;
+                continuity.beginTry(runSpec, nativeTry, attemptAbort);
                 // #363: bound before the spawn — a credential change mid-try voids it.
                 const refusal = this.credentials.bindPreProgressRefusal(adapter.id, runSpec);
                 const transientStart = telemetry.transientFailures.length;
@@ -1455,26 +1460,29 @@ export class Orchestrator {
                         suspensionVersion: () => interaction?.suspensionVersion?.() ?? 0,
                     });
                     for await (const ev of watched) {
-                        if (signal?.aborted)
-                            break;
                         rawPatch = captureRawPatchEnvelope(rawContextPacket !== null, rawPatch, ev);
                         if (ev.type === "patch_produced")
                             continue;
                         const safeEv = redactHarnessEvent(ev);
                         if (directory)
                             observeDirectoryPaths(observedPaths, safeEv, envelope.worktree_path);
-                        if (dropDeltaPastBudget(safeEv, deltaFlood, Orchestrator.MAX_DELTAS_PER_ATTEMPT, (t, p) => log?.emit(t, p), adapter.id, attemptId))
-                            continue;
-                        safeInvoke(onHarnessEvent, safeEv);
-                        // In-place turns run in the live tree under the native environment, so
-                        // the session they emit IS reachable for the next turn: record it. An
-                        // ISOLATED envelope-born session lives in the scoped home that dispose()
-                        // deletes, so observing it would poison the thread resume map with
-                        // unreachable ids — skip it there.
-                        if (inPlaceEnvelope)
-                            observeNativeSessionEvent(runInput, adapter.id, safeEv);
+                        const capped = dropDeltaPastBudget(safeEv, deltaFlood, Orchestrator.MAX_DELTAS_PER_ATTEMPT, (t, p) => log?.emit(t, p), adapter.id, attemptId);
+                        const display = !capped && safeEv.payload?.["buffered"] !== true;
+                        log?.emit("harness.event", harnessEventPayload(adapter.id, attemptId, safeEv), display);
+                        if (signal?.aborted)
+                            break;
+                        if (display)
+                            safeInvoke(onHarnessEvent, safeEv);
                         observeAuthSwitch(log, adapter.id, attemptId, safeEv);
                         observeAttemptTelemetry(telemetry, safeEv);
+                        const mismatch = continuity.observe(safeEv, runSpec, telemetry.outputMarkers);
+                        if (mismatch) {
+                            harnessErrored = true;
+                            errors.push(mismatch);
+                            break;
+                        }
+                        if (inPlaceEnvelope && continuity.mayPublishSession)
+                            observeNativeSessionEvent(runInput, adapter.id, safeEv);
                         // QA-024: the injected delegation belt's MCP server reported a
                         // terminal startup failure. Disclose it ONCE while live; recoverable
                         // exact tool-result failures are evaluated at attempt finalization.
@@ -1507,7 +1515,7 @@ export class Orchestrator {
                             cost = usage.cost;
                             costEstimated = usage.costEstimated;
                             if (usage.hardCapReached) {
-                                harnessErrored = true;
+                                harnessErrored = streamBudgetDenied = true;
                                 errors.push("budget hard cap reached mid-attempt; stream aborted");
                                 break;
                             }
@@ -1518,7 +1526,7 @@ export class Orchestrator {
                         }
                         // Capture assistant prose so an answer-only turn (no file changes) still
                         // has an honest output artifact; a TYPED final message wins verbatim.
-                        answer.observe(safeEv);
+                        answer.observeCounted(ev, safeEv);
                         // Observe ALL budget/quota signals (one codex usage event carries
                         // BOTH spend and quota); pressure disclosed once per attempt.
                         observeBudgetSignals(ledger, log, adapter.id, attemptId, safeEv, budgetSignalState);
@@ -1566,64 +1574,37 @@ export class Orchestrator {
                 const deliverableEmpty = workspaceUnchanged && answer.text().length === 0;
                 const delivered = !harnessErrored && !deliverableEmpty && !signal?.aborted;
                 this.credentials.noteTryServed(refusal, telemetry.outputMarkers, delivered);
-                // W5.4 + A2 failover: a typed-limit hit OR a structural pre-progress
-                // death rebuilds the spec on a NEW session under the next profile.
-                if (harnessErrored && runInput && !signal?.aborted) {
-                    const rotated = await rotateSpecOnTypedLimit({
-                        spec,
-                        harnessId: adapter.id,
-                        attemptId,
-                        policy: this.credentials.profilePolicy(contract.repo.root, adapter.id),
-                        registry: this.config(contract.repo.root)?.global.credential_profiles ?? [],
-                        snapshots: this.deps.quotaSnapshots?.() ?? [],
-                        probeReadyProfiles: () => this.credentials.readyProfileIdsForRotation(runInput, adapter.id, spec.credential_profile ?? null, triedProfiles, spec.model_hint ?? null),
-                        ...this.credentials.rotationObservations(adapter, spec, newTransients, refusal),
-                        triedProfiles,
-                        markers: telemetry.outputMarkers,
-                        requestRefused: Boolean(telemetry.requestRefusal),
-                        sawTypedLimit,
-                        sawRetryable,
-                        attemptErrored: harnessErrored,
-                        // Rotation evidence reads the POLICY-accepted try output: refusal
-                        // prose arriving as mid-stream MESSAGE events (claude org-disabled)
-                        // is no deliverable; the transient gate keeps RAW deliverableEmpty.
-                        deliverableEmpty: workspaceUnchanged && acceptedTryOutput(answer, harnessErrored).length === 0,
-                        workspaceDiffNonEmpty: !workspaceUnchanged,
-                        lastLimit: telemetry.rateLimits.at(-1) ?? null,
-                        emit: (type, payload) => log?.emit(type, payload),
-                        newSessionId: () => newId("ses"),
-                        defaultRouteWasVendorNative: routed.authRouteEstimate === "local_session",
-                        // D-U6: an explicit pin never rotates; pool-selected rows do.
-                        pinned: runInput.credentialProfileId != null,
-                    });
-                    // A5 ordering: an exhausted pool terminalizes TYPED here, BEFORE the
-                    // transient gate below burns same-profile retries (limits classify
-                    // as retryable) on the already-refused subject.
-                    if (rotated && "poolExhausted" in rotated) {
-                        poolExhausted = rotated.poolExhausted;
-                        errors.push(safeErrorMessage(poolExhausted));
-                        break;
-                    }
-                    if (rotated) {
-                        // INV-137: the rotated row runs in ITS OWN lane home (no-op for
-                        // isolated envelopes and native-env in-place turns).
-                        spec = rotatedSpecInLaneHome(spec, rotated, (id) => this.laneHomeEnvFor(runInput, adapter.id, id), runInput.credentialProfileId ?? null);
-                        applied = appliedNow();
-                        errors.length = 0;
-                        harnessErrored = false;
-                        continue;
-                    }
+                const verdict = await continuity.afterTry({
+                    runSpec,
+                    nativeTry,
+                    harnessErrored,
+                    budgetStopped: streamBudgetDenied,
+                    aborted: signal?.aborted === true,
+                    requestRefused: Boolean(telemetry.requestRefusal),
+                    newTransients,
+                    sawTypedLimit,
+                    sawRetryable,
+                    answer,
+                    rawDeliverableEmpty: deliverableEmpty,
+                    workspaceDiffNonEmpty: !workspaceUnchanged,
+                    currentDiff,
+                    markers: telemetry.outputMarkers,
+                    lastLimit: telemetry.rateLimits.at(-1) ?? null,
+                    refusal,
+                    telemetry,
+                });
+                if (verdict.kind === "terminal") {
+                    poolExhausted = verdict.error;
+                    errors.push(safeErrorMessage(poolExhausted));
+                    break;
                 }
-                if (!harnessErrored ||
-                    !sawRetryable ||
-                    !deliverableEmpty ||
-                    nativeTry >= retryPolicy.maxRetries ||
-                    signal?.aborted)
+                if (verdict.kind === "break")
                     break;
-                const delayMs = emitTransientRetryPlan((t, p) => log?.emit(t, p), adapter.id, attemptId, telemetry, nativeTry, retryPolicy);
+                spec = verdict.spec;
+                applied = appliedNow();
                 errors.length = 0;
                 harnessErrored = false;
-                await sleep(delayMs);
+                await sleep(verdict.delayMs);
             }
         }
         finally {
@@ -1643,19 +1624,23 @@ export class Orchestrator {
         // with no typed final contributes no answer material (acceptedTryOutput).
         const unwrapped = unwrapWorkReportEnvelope(acceptedTryOutput(answer, harnessErrored), workReportMode, { sideToolReport: telemetry.sideToolWorkReport ?? undefined });
         const redacted = redactSecrets(unwrapped.deliverable);
-        const candidateAnswer = redacted.trim().length > 0 ? redacted : undefined;
+        // INV-062: the (already redacted) answer is kept whatever the patch holds.
+        const answerText = redacted.trim().length > 0 ? redacted : undefined;
         if (directory)
             await captureDirectory();
-        const { diff, refusal: secretDiffRefusal } = directory
-            ? { diff: "", refusal: directoryCapture.refusal }
-            : await secretDiff.quarantineCandidateWorkspace(wsm, envelope, inPlaceEnvelope, candidateAnswer);
-        harnessErrored = secretDiff.recordSecretDiffRefusal(secretDiffRefusal, errors, harnessErrored);
-        const answerText = secretDiffRefusal ? undefined : candidateAnswer;
+        const captured = directory
+            ? { diff: "", captureRefusal: directoryCapture.refusal }
+            : await secretDiff.captureCandidateWorkspace({
+                ...{ wsm, envelope, inPlace: inPlaceEnvelope, projectRoot: store.repoRoot },
+                ...{ answerText, answerMatches: answer.secretLikeMatches() },
+            });
+        const { diff, captureRefusal } = captured;
+        harnessErrored = secretDiff.recordCaptureRefusal(captureRefusal, errors, harnessErrored);
         const deliverableEvidence = diff.trim().length > 0 || Boolean(answerText) || directoryHasOutput(directoryCapture.files);
         // Cancelled attempts skip gates: running a 600s-per-gate suite delays the ack
         // and burns compute on a result nobody will adopt. Diff/attempt.yaml
         // still land, so partial work stays inspectable.
-        const gateSignalAborted = signal?.aborted === true || secretDiffRefusal !== undefined;
+        const gateSignalAborted = signal?.aborted === true || captureRefusal !== undefined;
         if (!gateSignalAborted) {
             log?.emit("gate.started", {
                 attempt_id: attemptId,
@@ -1702,6 +1687,7 @@ export class Orchestrator {
             workReport: unwrapped.workReport,
             workReportSource: unwrapped.source,
             workReportViolation: unwrapped.contractViolation,
+            workReportUnverified: unwrapped.unverified ?? null,
             contextTerminalExhausted: telemetry.contextExhausted,
         });
         harnessErrored = finalized.harnessErrored;
@@ -1709,6 +1695,14 @@ export class Orchestrator {
             errors.push(`work_report contract: ${unwrapped.contractViolation}`);
         const deliverablePresent = finalized.deliverablePresent;
         const errored = harnessErrored || webBlocked;
+        const resumable = await continuity.finish({
+            runSpec: spec,
+            errored,
+            nonSuccess: !gatesPassed(gates),
+            aborted: signal?.aborted === true,
+            cancelReason: typeof signal?.reason === "string" ? signal.reason : null,
+            workState: finalized.workState,
+        });
         setAttemptOutcome(telemetry, {
             deliverablePresent,
             gatesPassed: gates.length > 0 ? gatesPassed(gates) : null,
@@ -1729,9 +1723,9 @@ export class Orchestrator {
             attemptDir,
             worktreePath: envelope.worktree_path,
             artifactRelativeDir,
-            diff,
-            persistPatch: !directory && secretDiffRefusal === undefined && isMutatingAccess(access),
-            persistProducedMedia: !directory && secretDiffRefusal === undefined,
+            ...{ diff, persistedDiff: captured.persistedDiff },
+            persistPatch: !directory && captureRefusal === undefined && isMutatingAccess(access),
+            persistProducedMedia: !directory && captureRefusal === undefined,
             answerText,
             record: {
                 attempt_id: attemptId,
@@ -1743,7 +1737,7 @@ export class Orchestrator {
                 errors: errors.slice(0, 5),
                 ...telemetrySummary(telemetry),
                 outcome: telemetry.outcome,
-                ...(secretDiffRefusal ? { secret_diff_refusal: secretDiffRefusal } : {}),
+                ...secretDiff.attemptDisclosure(captured),
                 gates: gates.map((g) => ({ id: g.id, status: g.status })),
                 branch: envelope.branch_name,
                 ...(directoryCapture.files
@@ -1765,11 +1759,17 @@ export class Orchestrator {
             estimated: costEstimated,
             settlement: attemptUsageCostSettlement(cost, costEstimated, attemptId, adapter.id, telemetry.authMode, telemetry.usageCost),
         });
+        for (const path of producedFiles)
+            log?.emit("output.ready", {
+                kind: "artifact",
+                path: `attempts/${attemptId}/produced/${path}`,
+                state: "diagnostic",
+            });
         return {
             attemptId,
             harnessId: adapter.id,
             label,
-            diff,
+            ...captured,
             ...(directoryCapture.files ? { files: directoryCapture.files } : {}),
             answerText,
             reviewCwd: envelope.worktree_path,
@@ -1781,7 +1781,6 @@ export class Orchestrator {
             costEstimated,
             errors: errors.slice(0, 8),
             telemetry,
-            ...(secretDiffRefusal ? { secretDiffRefusal } : {}),
             // A5: the typed refusal survives NORMAL attempt finalization (no throw).
             ...(telemetry.requestRefusal
                 ? { declaredFailure: requestRefusalFailure(telemetry.requestRefusal) }
@@ -1790,14 +1789,47 @@ export class Orchestrator {
                     : {}),
             outcomeClass: finalized.outcomeClass,
             applied,
+            ...continuity.terminalFacts(resumable),
         };
     }
-    interactionChannelFor(input, log, runId, taskId, attemptId, harnessId, 
-    // REQUIRED (no default): every call site must state the routed manifest's
-    // `interactive` capability, or a future site would silently bypass the gate.
-    supportsInteractive) {
-        // Thin delegate — the channel mechanics live in interaction.ts.
-        return interactionChannelFor(input, log, runId, taskId, attemptId, harnessId, supportsInteractive, DEFAULT_INTERACTION_TIMEOUT_MS);
+    continuityDeps(adapter, routed, contract, attemptId, paths, runInput, log, lane) {
+        const repoRoot = contract.repo.root;
+        const cwd = lane.envelope?.worktree_path ?? (runInput ? this.execRootOf(runInput) : repoRoot);
+        return {
+            adapter,
+            runId: paths.runId,
+            attemptId,
+            runDir: paths.root,
+            attemptDir: join(paths.attemptsDir, attemptId),
+            cwd,
+            workspace: continuityWorkspace(lane.envelope, cwd),
+            workOrder: lane.workOrder,
+            firstPrompt: lane.firstPrompt,
+            registry: this.config(repoRoot)?.global.credential_profiles ?? [],
+            policy: this.credentials.profilePolicy(repoRoot, adapter.id),
+            snapshots: this.deps.quotaSnapshots?.() ?? [],
+            retryPolicy: transientRetryPolicy(this.config(repoRoot)),
+            pinned: runInput?.credentialProfileId != null, // D-U6: a pin never rotates
+            defaultRouteWasVendorNative: routed.authRouteEstimate === "local_session",
+            requestedProfileId: runInput?.credentialProfileId ?? null,
+            rotationEnabled: runInput !== undefined,
+            laneEnvFor: (id) => (runInput ? this.laneHomeEnvFor(runInput, adapter.id, id) : null),
+            probeReadyProfiles: (spec, tried) => runInput
+                ? this.credentials.readyProfileIdsForRotation(runInput, adapter.id, spec.credential_profile ?? null, tried, spec.model_hint ?? null)
+                : Promise.resolve(new Set()),
+            rotationObservations: (spec, transients, refusal) => this.credentials.rotationObservations(adapter, spec, transients, refusal),
+            emit: (type, payload) => log?.emit(type, payload),
+            route: routed,
+            newSessionId: () => newId("ses"),
+            thread: runInput?.threadId
+                ? {
+                    threadId: runInput.threadId,
+                    turnId: runInput.threadContinuity?.turnId ?? null,
+                    onSessionObserved: runInput.onSessionObserved,
+                    onContinuityResolved: runInput.onContinuityResolved,
+                }
+                : null,
+        };
     }
     async runRace(input, mode, announce) {
         const taskId = input.taskId ?? newId("task");
@@ -1917,7 +1949,7 @@ export class Orchestrator {
         const disposeReviewEnvelopes = async () => {
             const envelopes = reviewEnvelopes.splice(0);
             for (const env of envelopes)
-                await wsm.dispose(env);
+                await kept.settle(wsm, env, runsBySlot);
         };
         const candidateAccess = contract.access.effective_profile;
         let budgetStopped = false;
@@ -1926,6 +1958,7 @@ export class Orchestrator {
         let budgetDenial = null;
         let softWarned = false;
         const requestedSingleCandidate = adapters.length === 1;
+        const kept = custody.forRun(input, requestedSingleCandidate && mutatingRun, runId, paths, log);
         const slots = [];
         for (let i = 0; i < adapters.length; i++) {
             const routed = adapters[i];
@@ -2025,7 +2058,7 @@ export class Orchestrator {
                     external_context_policy: knobs.webPolicy,
                     ...(knobs.ignored.length > 0 ? { ignored_settings: knobs.ignored } : {}),
                 });
-                envelope = await wsm.create({
+                envelope = await kept.envelope(wsm, {
                     taskId,
                     attemptId: slot.attemptId,
                     baseRef: contract.repo.base_ref,
@@ -2047,11 +2080,7 @@ export class Orchestrator {
                         budgetStopped = true;
                         budgetDenial ??= denial;
                     },
-                }, candidateAccess, (ev) => {
-                    const safeEv = redactHarnessEvent(ev);
-                    safeInvoke(input.onHarnessEvent, safeEv);
-                    log.emit("harness.event", harnessEventPayload(adapter.id, slot.attemptId, safeEv));
-                }, input.signal, downgradeModel ?? undefined, input.effort, this.candidateIntent(input), log, effectiveWeb, this.interactionChannelFor(input, log, runId, taskId, slot.attemptId, adapter.id, slot.routed.supportsInteractive), (streamedUsd) => {
+                }, candidateAccess, input.onHarnessEvent, input.signal, downgradeModel ?? undefined, input.effort, this.candidateIntent(input), log, effectiveWeb, interactionChannelFor(input, log, runId, taskId, slot.attemptId, adapter.id, slot.routed.supportsInteractive), (streamedUsd) => {
                     ledger.updateHold(slot.lease.lease_id, streamedUsd);
                     if (ledger.tier() !== "hard")
                         return false;
@@ -2094,7 +2123,7 @@ export class Orchestrator {
                             harness: adapter.id,
                             profileId: input.credentialProfileId ?? null,
                             priorPrompt: input.prompt,
-                            priorOutput: run.answerText ?? run.diff ?? "",
+                            priorOutput: run.answerText ?? run.persistedDiff ?? run.diff ?? "",
                         }));
                         // Reserve the continuation lease BEFORE any disclosure: a denied lease
                         // must never emit run.continuation (which claims a continuation
@@ -2130,11 +2159,7 @@ export class Orchestrator {
                                         budgetStopped = true;
                                         budgetDenial ??= denial;
                                     },
-                                }, candidateAccess, (ev) => {
-                                    const safeEv = redactHarnessEvent(ev);
-                                    safeInvoke(input.onHarnessEvent, safeEv);
-                                    log.emit("harness.event", harnessEventPayload(adapter.id, contAttemptId, safeEv));
-                                }, input.signal, downgradeModel ?? undefined, input.effort, this.candidateIntent(input), log, effectiveWeb, this.interactionChannelFor(input, log, runId, taskId, contAttemptId, adapter.id, slot.routed.supportsInteractive), (streamedUsd) => {
+                                }, candidateAccess, input.onHarnessEvent, input.signal, downgradeModel ?? undefined, input.effort, this.candidateIntent(input), log, effectiveWeb, interactionChannelFor(input, log, runId, taskId, contAttemptId, adapter.id, slot.routed.supportsInteractive), (streamedUsd) => {
                                     ledger.updateHold(contLeaseId, streamedUsd);
                                     if (ledger.tier() !== "hard")
                                         return false;
@@ -2221,7 +2246,7 @@ export class Orchestrator {
             }
             finally {
                 if (envelope)
-                    await wsm.dispose(envelope); // no worktree leak even on create/run error
+                    await kept.settle(wsm, envelope, runsBySlot); // no leak on create/run error
             }
         };
         await runParallelCandidates(slots, this.deps.runtimeConcurrencyCaps, runSlot);
@@ -2238,6 +2263,16 @@ export class Orchestrator {
             mode,
             ledger,
             runs,
+            git: input.workspaceKind !== "directory"
+                ? {
+                    live: input.inPlace === true &&
+                        requestedSingleCandidate &&
+                        runs[0]?.reviewCwd === execRoot,
+                    execRoot,
+                    preTurnSha,
+                    postTurnSha: earlyPostTurnSha,
+                }
+                : undefined,
             signal: input.signal,
             writeTelemetry: () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null),
         });
@@ -2252,7 +2287,7 @@ export class Orchestrator {
             input.workspaceKind !== "directory" &&
             input.inPlace &&
             requestedSingleCandidate &&
-            runs.every((run) => !run.secretDiffRefusal)) {
+            runs.every((run) => !run.captureRefusal)) {
             try {
                 earlyPostTurnSha = await snapshotTree(execRoot);
             }
@@ -2365,7 +2400,7 @@ export class Orchestrator {
         catch (err) {
             // Review preflight/evidence failures end TERMINALLY with artifacts —
             // never as an escaped throw that orphans the run dir.
-            return failTerminally(log, store, paths, runId, taskId, mode, "review", err, ledger.spend());
+            return failAfterCandidates({ log, store, paths, runId, taskId, mode, ledger, runs }, "review", err);
         }
         finally {
             // Review preflight failures must not leak candidate worktrees.
@@ -2423,11 +2458,7 @@ export class Orchestrator {
                             budgetStopped = true;
                             budgetDenial ??= denial;
                         },
-                    }, candidateAccess, (ev) => {
-                        const safeEv = redactHarnessEvent(ev);
-                        safeInvoke(input.onHarnessEvent, safeEv);
-                        log.emit("harness.event", harnessEventPayload(synthAdapter.id, "synth", safeEv));
-                    }, input.signal, undefined, input.effort, "synthesize", log, effectiveWeb, this.interactionChannelFor(input, log, runId, taskId, "synth", synthAdapter.id, synthRouted.supportsInteractive), undefined, input, false, synthesisInput.content, undefined, synthHome);
+                    }, candidateAccess, input.onHarnessEvent, input.signal, undefined, input.effort, "synthesize", log, effectiveWeb, interactionChannelFor(input, log, runId, taskId, "synth", synthAdapter.id, synthRouted.supportsInteractive), undefined, input, false, synthesisInput.content, undefined, synthHome);
                     ledger.settle(lease.lease?.lease_id ?? "", attemptUsageCostSettlement(run.cost, run.costEstimated, run.attemptId, run.harnessId, run.telemetry.authMode, run.telemetry.usageCost));
                     reviewEnvelopes.push(envelope);
                     envelope = undefined;
@@ -2474,7 +2505,7 @@ export class Orchestrator {
         }
         catch (err) {
             // Arbitration throws end terminally with artifacts, never as an orphan.
-            return failTerminally(log, store, paths, runId, taskId, mode, "arbitration", err, ledger.spend());
+            return failAfterCandidates({ log, store, paths, runId, taskId, mode, ledger, runs }, "arbitration", err);
         }
         log.emit("arbitration.completed", {
             winner: result.decision.winner,
@@ -2620,9 +2651,8 @@ export class Orchestrator {
                 });
             }
             else if (mutatingRun) {
-                secretDiff.assertNoSecretLikeTokens("final patch diff", winnerRun.diff);
-                const patchSha256 = sha256(winnerRun.diff);
-                store.writeText(join(paths.finalDir, "patch.diff"), winnerRun.diff);
+                const savedPatch = secretDiff.persistFinalPatch(store, paths.finalDir, winnerRun);
+                const patchSha256 = savedPatch.patchSha256;
                 const wstats = diffStats(winnerRun.diff);
                 const hasDiff = winnerRun.diff.trim().length > 0;
                 const blockers = winnerEvidence
@@ -2718,7 +2748,7 @@ export class Orchestrator {
                         outcome_facts: facts,
                         review_verified: actualReviewVerified,
                         budget_stopped: budgetStopped,
-                        patch_sha256: patchSha256,
+                        ...{ patch_sha256: patchSha256, ...savedPatch.meta },
                         result_kind: resultKind,
                         diffstat: {
                             files: wstats.paths.length,
@@ -2731,10 +2761,11 @@ export class Orchestrator {
                         pre_turn_sha: preTurnSha,
                         post_turn_sha: postTurnSha,
                         revert_anchor_id: revertAnchorId,
+                        execution_root: adopted === true ? execRoot : null,
                     },
                 });
             }
-            store.writeText(join(paths.finalDir, "summary.md"), renderSummary(runId, mode, { ...result.decision, facts }, evidences, synth.reason, actualReviewVerified));
+            store.writeText(join(paths.finalDir, "summary.md"), renderSummary(runId, mode, { ...result.decision, facts }, evidences, synth.reason, actualReviewVerified, secretDiff.secretLikeSummaryLine(winnerRun.secretLike)));
             // summary.md is a DIAGNOSTIC artifact only (V8/PLAN addendum 2): it no
             // longer carries primary-output authority. A clean applyable success or a
             // winner answer still marks it ready for legacy INV-116 ordering; any
@@ -2839,7 +2870,12 @@ export class Orchestrator {
             log.emit("work_product.emitted", { winner: result.decision.winner });
         }
         if (!isFailureTerminal) {
-            log.emit("run.completed", { lifecycle: facts.lifecycle, facts, reason: facts.reason });
+            log.emit("run.completed", {
+                lifecycle: facts.lifecycle,
+                facts,
+                reason: facts.reason,
+                ...resumableTerminal(store, paths, winnerRun ? [winnerRun] : runs, isFailureTerminal),
+            });
         }
         else if (facts.lifecycle === "succeeded") {
             // needsDecision at terminal — the event's phase must agree with
@@ -2847,6 +2883,7 @@ export class Orchestrator {
             log.emit("run.blocked", {
                 lifecycle: facts.lifecycle,
                 facts,
+                ...resumableTerminal(store, paths, runs, isFailureTerminal),
                 phase: deliveryFailureReason && !finalVerifyFailed
                     ? "delivery"
                     : finalVerifyFailed
@@ -2862,6 +2899,7 @@ export class Orchestrator {
                 reason: facts.reason,
                 phase: "arbitration",
                 failure_ref: "final/failure.yaml",
+                ...resumableTerminal(store, paths, runs, isFailureTerminal),
             });
         }
         return {
@@ -2910,6 +2948,7 @@ export class Orchestrator {
     reviewScoped(input) {
         return reviewCandidate({
             ...input,
+            credentialObserverFactory: this.deps.credentialObserverFactory,
             reviewerTimeoutMs: input.reviewerTimeoutMs ?? reviewerTimeoutMs(this.config(input.cwd)),
             transientRetryPolicy: input.transientRetryPolicy ?? transientRetryPolicy(this.config(input.cwd)),
         });
@@ -3222,11 +3261,7 @@ export class Orchestrator {
                             exhausted = true;
                             processingBudgetDenial ??= denial;
                         },
-                    }, convergenceAccess, (ev) => {
-                        const safeEv = redactHarnessEvent(ev);
-                        safeInvoke(input.onHarnessEvent, safeEv);
-                        log.emit("harness.event", harnessEventPayload(adapter.id, attemptId, safeEv));
-                    }, input.signal, undefined, input.effort, "repair", log, effectiveWeb, this.interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive), (streamedUsd) => {
+                    }, convergenceAccess, input.onHarnessEvent, input.signal, undefined, input.effort, "repair", log, effectiveWeb, interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive), (streamedUsd) => {
                         ledger.updateHold(lease.lease?.lease_id ?? "", streamedUsd);
                         return ledger.tier() === "hard";
                     }, input, true, // convergence runs one candidate: live deltas on (W-C4)
@@ -3279,7 +3314,7 @@ export class Orchestrator {
                             observedPaths: [...observedPaths],
                         });
                         run.files = captured.files;
-                        run.secretDiffRefusal = captured.refusal;
+                        run.captureRefusal = captured.refusal;
                     }
                 }
                 lastRun = run;
@@ -3287,6 +3322,18 @@ export class Orchestrator {
                 // per attempt, so the proof is spent per attempt.
                 assertDelegatedEvidence(input.delegated === true, convergenceAccess, [run]);
                 attemptTelemetries.push({ attemptId, harnessId: adapter.id, telemetry: run.telemetry });
+                lastPostTurnSha = null;
+                // Post-mutation fence for in-place: snapshot the live tree NOW (after the
+                // harness mutated it, before this attempt's review). The last attempt's
+                // value is the revert target persisted into work_product.yaml.
+                if (input.inPlace === true && input.workspaceKind !== "directory" && !run.captureRefusal) {
+                    try {
+                        lastPostTurnSha = await snapshotTree(execRoot);
+                    }
+                    catch {
+                        lastPostTurnSha = null;
+                    }
+                }
                 // Cancellation/deadline keeps priority over a belt failure finalized concurrently.
                 if (input.signal?.aborted || processingBudgetDenial)
                     break;
@@ -3319,7 +3366,7 @@ export class Orchestrator {
                     this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, attemptTelemetries, null);
                     return failTerminally(log, store, paths, runId, taskId, mode, failure.phase, failure.error, ledger.spend(), failure.metadata);
                 }
-                if (input.workspaceKind === "directory" && run.secretDiffRefusal) {
+                if (input.workspaceKind === "directory" && run.captureRefusal) {
                     return failedCandidatesResult({
                         ledger,
                         mode,
@@ -3338,17 +3385,6 @@ export class Orchestrator {
                     interrupted = true;
                     break;
                 }
-                // Post-mutation fence for in-place: snapshot the live tree NOW (after the
-                // harness mutated it, before this attempt's review). The last attempt's
-                // value is the revert target persisted into work_product.yaml.
-                if (input.inPlace === true && input.workspaceKind !== "directory") {
-                    try {
-                        lastPostTurnSha = await snapshotTree(execRoot);
-                    }
-                    catch {
-                        lastPostTurnSha = null;
-                    }
-                }
                 // The review round is wrapped so a preflight/revalidation throw ends the
                 // run TERMINALLY with artifacts instead of orphaning the run dir.
                 let conv;
@@ -3399,7 +3435,7 @@ export class Orchestrator {
                             facts: makeOutcomeFacts("failed", { noChanges: run.files.noChanges }),
                             log,
                         });
-                    return failTerminally(log, store, paths, runId, taskId, mode, "review", err, ledger.spend());
+                    return failAfterCandidates({ log, store, paths, runId, taskId, mode, ledger, runs: [run] }, "review", err);
                 }
                 if (conv.converged) {
                     converged = true;
@@ -3590,15 +3626,10 @@ export class Orchestrator {
                     facts,
                     log,
                 });
-                if (lastRun.answerText) {
-                    store.writeText(join(paths.finalDir, "answer.md"), lastRun.answerText);
-                    log.emit("output.ready", { kind: "answer", path: "final/answer.md" });
-                }
             }
             else {
-                secretDiff.assertNoSecretLikeTokens("final patch diff", lastRun.diff);
-                const patchSha256 = sha256(lastRun.diff);
-                store.writeText(join(paths.finalDir, "patch.diff"), lastRun.diff);
+                const savedPatch = secretDiff.persistFinalPatch(store, paths.finalDir, lastRun);
+                const patchSha256 = savedPatch.patchSha256;
                 // Honest apply-state (parity with runRace single-candidate in-place): a
                 // convergence run with inPlace mutated the live tree directly across its
                 // attempts, so it is "applied" even when review blocked (Revert offered).
@@ -3625,16 +3656,22 @@ export class Orchestrator {
                         lifecycle: facts.lifecycle,
                         outcome_facts: facts,
                         review_verified: actualReviewVerified,
-                        patch_sha256: patchSha256,
+                        ...{ patch_sha256: patchSha256, ...savedPatch.meta },
                         adopted: convAdopted,
                         apply_state: convApplyState,
                         pre_turn_sha: convAdopted === true ? preTurnSha : null,
                         post_turn_sha: convAdopted === true ? lastPostTurnSha : null,
                         revert_anchor_id: revertAnchorId,
+                        execution_root: convAdopted === true ? execRoot : null,
                     },
                 });
             }
-            store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Attempts: ${attempt}\n- Winner: ${lastRun.attemptId}\n- Review verified (cross-family): ${actualReviewVerified}\n- Apply recommendation: ${decision?.apply_recommendation ?? "inspect"}${stuckNoProgressReason ? `\n- No-progress reason: ${stuckNoProgressReason}` : ""}\n`);
+            // INV-062: the answer is kept for every convergence result, patch or files.
+            if (lastRun.answerText) {
+                store.writeText(join(paths.finalDir, "answer.md"), lastRun.answerText);
+                log.emit("output.ready", { kind: "answer", path: "final/answer.md" });
+            }
+            store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Attempts: ${attempt}\n- Winner: ${lastRun.attemptId}\n- Review verified (cross-family): ${actualReviewVerified}\n- Apply recommendation: ${decision?.apply_recommendation ?? "inspect"}${stuckNoProgressReason ? `\n- No-progress reason: ${stuckNoProgressReason}` : ""}${secretDiff.summaryDisclosure(lastRun.secretLike)}\n`);
             // Lifecycle invariant (all modes): output.ready precedes the terminal
             // event so a client that applied the terminal event has the output.
             log.emit("output.ready", {
@@ -3646,6 +3683,7 @@ export class Orchestrator {
         // A needs-decision terminal (review blocked / checks failed) writes a
         // failure record + fires run.blocked even though the lifecycle succeeded.
         const convIsFailureTerminal = facts.lifecycle !== "succeeded" || convNeedsDecision;
+        const continuation = resumableTerminal(store, paths, lastRun ? [lastRun] : [], convIsFailureTerminal);
         if (convIsFailureTerminal) {
             // A5 last-result lift: the LAST attempt's typed mid-attempt refusal
             // survives onto the terminal; budget/cancel/needs-decision outrank it.
@@ -3721,6 +3759,7 @@ export class Orchestrator {
         }
         if (!convIsFailureTerminal) {
             log.emit("run.completed", {
+                ...continuation,
                 lifecycle: facts.lifecycle,
                 facts,
                 reason: facts.reason,
@@ -3729,6 +3768,7 @@ export class Orchestrator {
         }
         else if (facts.lifecycle === "succeeded") {
             log.emit("run.blocked", {
+                ...continuation,
                 lifecycle: facts.lifecycle,
                 facts,
                 attempts: attempt,
@@ -3738,6 +3778,7 @@ export class Orchestrator {
         }
         else {
             log.emit("run.failed", {
+                ...continuation,
                 lifecycle: facts.lifecycle,
                 facts,
                 reason: facts.reason,
@@ -3816,7 +3857,7 @@ export class Orchestrator {
                 spec.extra["abortSignal"] = input.signal
                     ? AbortSignal.any([input.signal, plannerAbort.signal])
                     : plannerAbort.signal;
-                const planInteraction = this.interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive);
+                const planInteraction = interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive);
                 if (planInteraction)
                     spec.extra["interactionChannel"] = planInteraction;
                 const planWorkMode = applyWorkEnvelope(spec, this.workReportEnvelopeFor(routed, contract, Boolean(planInteraction)));
@@ -4409,18 +4450,14 @@ export class Orchestrator {
                         : null) ?? roHome.env,
                 });
                 this.credentials.stampProfileSelection(spec, input, adapter.id);
-                const reportAbort = new AbortController();
-                spec.extra["abortSignal"] = input.signal
-                    ? AbortSignal.any([input.signal, reportAbort.signal])
-                    : reportAbort.signal;
-                const reportInteraction = this.interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive);
+                const reportInteraction = interactionChannelFor(input, log, runId, taskId, attemptId, adapter.id, routed.supportsInteractive);
                 if (reportInteraction)
                     spec.extra["interactionChannel"] = reportInteraction;
                 // D-16: compile the WorkReport envelope for the read-only lane.
                 const readonlyWorkEnvelope = this.workReportEnvelopeFor(routed, contract, Boolean(reportInteraction));
                 const readonlyWorkMode = applyWorkEnvelope(spec, readonlyWorkEnvelope);
                 const attemptEventsPath = join(paths.attemptsDir, attemptId, "events.jsonl");
-                const answer = new AnswerAssembly();
+                const answer = new secretDiff.CountedAnswerAssembly();
                 const telemetry = createAttemptTelemetry(knobs.webPolicy, contract.external_context.web_required, effectiveWeb, [], 
                 // Requested-model capture so ask/audit route receipts detect a silent
                 // model downgrade (typed model_mismatch), not just agent runs.
@@ -4428,7 +4465,6 @@ export class Orchestrator {
                 return {
                     knobs,
                     spec,
-                    reportAbort,
                     reportInteraction,
                     readonlyWorkMode,
                     attemptEventsPath,
@@ -4470,13 +4506,20 @@ export class Orchestrator {
                 }
                 return { status: "launched" };
             }
-            const { knobs, spec: preparedSpec, reportAbort, reportInteraction, readonlyWorkMode, attemptEventsPath, telemetry, } = preparation.value;
+            const { knobs, spec: preparedSpec, reportInteraction, readonlyWorkMode, attemptEventsPath, telemetry, } = preparation.value;
             let { answer } = preparation.value;
             let spec = preparedSpec;
             bindProcessingAdmission(spec, ledger, lease.lease, adapter.id, attemptId, undefined, processingAdmission);
             const retryPolicy = transientRetryPolicy(this.config(input.repoRoot));
             let activeSessionId = spec.session_id;
             const live = liveAttempt(input, routed, paths, contract, attemptId, () => activeSessionId);
+            let continuity;
+            ({ continuity, spec } = await openContinuity(this.continuityDeps(adapter, routed, contract, attemptId, paths, input, log, {
+                envelope: null,
+                harnessHome: null,
+                workOrder: input.prompt,
+                firstPrompt: spec.prompt,
+            }), { spec, continuation: input.continuation, store, telemetry }));
             const onAbort = () => void adapter.cancel?.(activeSessionId)?.catch(() => { });
             if (input.signal) {
                 if (input.signal.aborted)
@@ -4491,12 +4534,11 @@ export class Orchestrator {
             let processingRefusal = null;
             let poolExhausted = null; // A5: typed pool-exhausted refusal
             try {
-                const triedProfiles = new Set(); // W5.4 failover: each profile at most once
                 for (let nativeTry = 0; !input.signal?.aborted; nativeTry += 1) {
                     // A3 per-try isolation (candidate-lane parity): neither a failed try's
                     // output nor its progress markers leak into the next try's evidence.
                     if (nativeTry > 0) {
-                        answer = new AnswerAssembly();
+                        answer = new secretDiff.CountedAnswerAssembly();
                         telemetry.outputMarkers = newAttemptOutputMarkers();
                     }
                     const runSpec = nativeTry === 0
@@ -4504,10 +4546,14 @@ export class Orchestrator {
                         : HarnessRunSpec.parse({
                             ...spec,
                             session_id: newId("ses"),
-                            resume_session_id: null,
                             extra: { ...spec.extra },
                         });
                     activeSessionId = runSpec.session_id;
+                    const tryAbort = new AbortController();
+                    runSpec.extra["abortSignal"] = input.signal
+                        ? AbortSignal.any([input.signal, tryAbort.signal])
+                        : tryAbort.signal;
+                    continuity.beginTry(runSpec, nativeTry, tryAbort);
                     // #363: bound before the spawn — a credential change mid-try voids it.
                     const refusal = this.credentials.bindPreProgressRefusal(adapter.id, runSpec);
                     const transientStart = telemetry.transientFailures.length;
@@ -4525,29 +4571,29 @@ export class Orchestrator {
                             timeoutMs: harnessInactivityTimeoutMs(this.config(input.repoRoot)),
                             countsAsProgress: countsAsAgentProgress,
                             onTimeout: () => {
-                                reportAbort.abort();
+                                tryAbort.abort();
                                 void adapter.cancel?.(activeSessionId)?.catch(() => { });
                             },
                             isSuspended: () => (reportInteraction?.pendingCount?.() ?? 0) > 0,
                             suspensionVersion: () => reportInteraction?.suspensionVersion?.() ?? 0,
                         });
                         for await (const ev of watchedReport) {
-                            if (input.signal?.aborted)
-                                break;
                             const safeEv = redactHarnessEvent(ev);
-                            safeInvoke(input.onHarnessEvent, safeEv);
-                            // A thread ASK turn IS a chat turn now (INV-034): its native
-                            // session lives in the DURABLE per-lane home, so record it for the
-                            // next lane turn's resume. The read-only fallback chain is
-                            // sequential (never the parallel deep-scan swarm, which is
-                            // excluded from `laneRun`), so recordSession's upsert keeps the
-                            // latest lane session without a race.
-                            if (laneRun)
-                                observeNativeSessionEvent(input, adapter.id, safeEv);
+                            if (safeEv.payload?.["buffered"] !== true)
+                                safeInvoke(input.onHarnessEvent, safeEv);
                             observeAuthSwitch(log, adapter.id, attemptId, safeEv);
-                            log.emit("harness.event", harnessEventPayload(adapter.id, attemptId, safeEv));
+                            log.emit("harness.event", harnessEventPayload(adapter.id, attemptId, safeEv), safeEv.payload?.["buffered"] !== true);
                             appendLine(attemptEventsPath, JSON.stringify(safeEv));
+                            if (input.signal?.aborted)
+                                break;
                             observeAttemptTelemetry(telemetry, safeEv);
+                            const mismatch = continuity.observe(safeEv, runSpec, telemetry.outputMarkers);
+                            if (mismatch) {
+                                harnessError = mismatch;
+                                break;
+                            }
+                            if (laneRun && continuity.mayPublishSession)
+                                observeNativeSessionEvent(input, adapter.id, safeEv);
                             emitPlanProgress((t, p) => log.emit(t, p), adapter.id, attemptId, safeEv);
                             // read-only routes burn quota too (the orchestrate PLANNER is
                             // the loudest) — same single owner as the agent loop.
@@ -4561,12 +4607,12 @@ export class Orchestrator {
                                 budgetStopped = streamBudgetDenied = true;
                                 budgetDenial ??= streamDenial;
                                 harnessError = streamDenial.reason;
-                                reportAbort.abort();
+                                tryAbort.abort();
                                 void adapter.cancel?.(activeSessionId)?.catch(() => { });
                                 break;
                             }
                             // A TYPED final message wins verbatim over joined narration.
-                            answer.observe(safeEv);
+                            answer.observeCounted(ev, safeEv);
                             if (safeEv.type === "error")
                                 harnessError = safeEv.error
                                     ? redactSecrets(safeEv.error)
@@ -4594,62 +4640,34 @@ export class Orchestrator {
                     const reportSoFar = answer.text();
                     const delivered = !harnessError && reportSoFar.length > 0 && !input.signal?.aborted;
                     this.credentials.noteTryServed(refusal, telemetry.outputMarkers, delivered);
-                    // W5.4 + A2 reactive failover, READ-ONLY lane (same contract as the
-                    // candidate lane: typed limit or structural pre-progress death).
-                    if (harnessError && !input.signal?.aborted) {
-                        const rotated = await rotateSpecOnTypedLimit({
-                            spec,
-                            harnessId: adapter.id,
-                            attemptId,
-                            policy: this.credentials.profilePolicy(input.repoRoot, adapter.id),
-                            registry: this.config(input.repoRoot)?.global.credential_profiles ?? [],
-                            snapshots: this.deps.quotaSnapshots?.() ?? [],
-                            probeReadyProfiles: () => this.credentials.readyProfileIdsForRotation(input, adapter.id, spec.credential_profile ?? null, triedProfiles, spec.model_hint ?? null),
-                            ...this.credentials.rotationObservations(adapter, spec, newTransients, refusal),
-                            triedProfiles,
-                            markers: telemetry.outputMarkers,
-                            requestRefused: Boolean(telemetry.requestRefusal),
-                            sawTypedLimit,
-                            sawRetryable,
-                            attemptErrored: harnessError !== null,
-                            // Same policy owner as the candidate lane: an errored try's
-                            // narration is not a report; the transient gate keeps reportSoFar.
-                            deliverableEmpty: acceptedTryOutput(answer, harnessError !== null).length === 0,
-                            lastLimit: telemetry.rateLimits.at(-1) ?? null,
-                            emit: (type, payload) => log.emit(type, payload),
-                            newSessionId: () => newId("ses"),
-                            defaultRouteWasVendorNative: routed.authRouteEstimate === "local_session",
-                            // D-U6: an explicit pin never rotates; pool-selected rows do.
-                            pinned: input.credentialProfileId != null,
-                        });
-                        // A5 ordering: same as the candidate lane — terminalize typed
-                        // before the transient gate burns same-profile retries. The pool
-                        // refusal APPENDS to the original harness error (candidate-lane
-                        // parity: errors.push) instead of erasing the true failure.
-                        if (rotated && "poolExhausted" in rotated) {
-                            poolExhausted = rotated.poolExhausted;
-                            harnessError = harnessError
-                                ? `${harnessError}; ${safeErrorMessage(poolExhausted)}`
-                                : safeErrorMessage(poolExhausted);
-                            break;
-                        }
-                        if (rotated) {
-                            // INV-137: the rotated row's session must land in ITS OWN lane
-                            // home — never the previous row's lane store.
-                            spec = rotatedSpecInLaneHome(spec, rotated, (id) => this.laneHomeEnvFor(input, adapter.id, id), input.credentialProfileId ?? null);
-                            harnessError = null;
-                            continue;
-                        }
+                    const verdict = await continuity.afterTry({
+                        runSpec,
+                        nativeTry,
+                        harnessErrored: harnessError !== null,
+                        aborted: input.signal?.aborted === true,
+                        requestRefused: Boolean(telemetry.requestRefusal),
+                        newTransients,
+                        sawTypedLimit,
+                        sawRetryable,
+                        answer,
+                        rawDeliverableEmpty: reportSoFar.length === 0,
+                        markers: telemetry.outputMarkers,
+                        lastLimit: telemetry.rateLimits.at(-1) ?? null,
+                        refusal,
+                        telemetry,
+                    });
+                    if (verdict.kind === "terminal") {
+                        poolExhausted = verdict.error;
+                        harnessError = harnessError
+                            ? `${harnessError}; ${safeErrorMessage(poolExhausted)}`
+                            : safeErrorMessage(poolExhausted);
+                        break;
                     }
-                    if (!harnessError ||
-                        !sawRetryable ||
-                        reportSoFar.length > 0 ||
-                        nativeTry >= retryPolicy.maxRetries ||
-                        input.signal?.aborted)
+                    if (verdict.kind === "break")
                         break;
-                    const delayMs = emitTransientRetryPlan((t, p) => log.emit(t, p), adapter.id, attemptId, telemetry, nativeTry, retryPolicy);
+                    spec = verdict.spec;
                     harnessError = null;
-                    await sleep(delayMs);
+                    await sleep(verdict.delayMs);
                 }
             }
             finally {
@@ -4691,6 +4709,7 @@ export class Orchestrator {
                 workReport: roUnwrapped.workReport,
                 workReportSource: roUnwrapped.source,
                 workReportViolation: roUnwrapped.contractViolation,
+                workReportUnverified: roUnwrapped.unverified ?? null,
                 contextTerminalExhausted: telemetry.contextExhausted,
             });
             // A broken WorkReport contract is a hard failure ONLY when the finalizer
@@ -4713,6 +4732,13 @@ export class Orchestrator {
                 // interruptions keep the strict deliverable requirement.
                 emptyDeliverableAllowed: roFinalized.outcomeClass === "clean",
             });
+            const roResumable = await continuity.finish({
+                runSpec: spec,
+                errored: harnessError !== null,
+                aborted: input.signal?.aborted === true,
+                cancelReason: typeof input.signal?.reason === "string" ? input.signal.reason : null,
+                workState: roFinalized.workState,
+            });
             if (harnessError) {
                 log.emit("harness.completed", {
                     harness_id: adapter.id,
@@ -4733,6 +4759,7 @@ export class Orchestrator {
                         : poolExhausted || processingRefusal
                             ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
                             : {}),
+                    ...continuity.terminalFacts(roResumable),
                 });
                 if (opts.deepScan) {
                     store.writeText(join(paths.findingsDir, `${attemptId}-error.md`), `# Explorer ${attemptId} failed\n\n${harnessError}\n`);
@@ -4753,9 +4780,11 @@ export class Orchestrator {
                 harnessId: adapter.id,
                 status: scoutInterrupted ? "failed" : "success",
                 report: report || "(no output)",
+                answerMatches: answer.secretLikeMatches(),
                 error: scoutInterrupted ? "context capacity exhausted before the scout completed" : null,
                 telemetry,
                 ...(scoutInterrupted ? { interrupted: true } : {}),
+                ...continuity.terminalFacts(roResumable),
             });
             if (opts.deepScan) {
                 const warningNote = toolWarnings(telemetry).length
@@ -4917,7 +4946,7 @@ export class Orchestrator {
             harnessId: a.harnessId,
             status: a.status,
         }));
-        const cancelledTerminal = () => cancelledResult(log, runId, taskId, opts.mode, paths.root, candidateSummaries, () => this.writeRunTelemetry(store, paths, contract, runId, taskId, opts.mode, attemptTelemetries, null), ledger.spend(), input.signal, store);
+        const cancelledTerminal = () => cancelledResult(log, runId, taskId, opts.mode, paths.root, candidateSummaries, () => this.writeRunTelemetry(store, paths, contract, runId, taskId, opts.mode, attemptTelemetries, null), ledger.spend(), input.signal, store, undefined, resumableOf(attempts, "cancelled"));
         if (input.signal?.aborted)
             return cancelledTerminal();
         const succeededReadonly = attempts.filter((a) => a.status === "success");
@@ -4943,14 +4972,6 @@ export class Orchestrator {
                 fallbackOpen = false;
             }
             const partialReport = [...attempts].reverse().find((a) => a.report)?.report ?? "";
-            if (partialReport) {
-                store.writeText(join(paths.finalDir, opts.artifactName), `# ${opts.title}\n\n> Unverified partial output. The run is ${webBlocked ? "blocked" : "failed"} because a required/attempted tool failed.\n\n${partialReport}\n`);
-                log.emit("output.ready", {
-                    kind: opts.mode === "ask" ? "answer" : "report",
-                    path: `final/${opts.artifactName}`,
-                    state: "diagnostic",
-                });
-            }
             this.writeRunTelemetry(store, paths, contract, runId, taskId, opts.mode, attemptTelemetries, null);
             store.writeText(join(paths.contextDir, "context_error.md"), `# ${budgetMapping ? "Budget Denied" : "Harness Error"}\n\n${singleError}\n`);
             const roEventRefs = attempts.map((a) => `attempts/${a.attemptId}/events.jsonl`);
@@ -5002,6 +5023,7 @@ export class Orchestrator {
                     harness_id: terminalHarnessId,
                     error: singleError,
                     failure_ref: "final/failure.yaml",
+                    ...resumableTerminal(store, paths, attempts, true),
                 });
             }
             else {
@@ -5013,6 +5035,7 @@ export class Orchestrator {
                     harness_id: terminalHarnessId,
                     error: singleError,
                     failure_ref: "final/failure.yaml",
+                    ...resumableTerminal(store, paths, attempts, true),
                 });
             }
             return {
@@ -5086,6 +5109,7 @@ export class Orchestrator {
                 phase: scanBudgetMapping ? scanBudgetMapping.phase : "harness",
                 error: message,
                 failure_ref: "final/failure.yaml",
+                ...resumableTerminal(store, paths, attempts, true),
             });
             return {
                 spendUsd: ledger.spend(),
@@ -5112,8 +5136,9 @@ export class Orchestrator {
         // whole decision + reducer spawn lives in deepScanReducer.ts (its owner).
         let deepScanSynthesis = null;
         let reducedReport = null;
+        let answerMatches = succeeded.reduce((sum, a) => sum + (a.answerMatches ?? 0), 0);
         if (opts.deepScan) {
-            ({ deepScanSynthesis, reducedReport } = await resolveDeepScanSynthesis(this.deepScanReducerDeps(input, contract, log), {
+            ({ deepScanSynthesis, reducedReport, answerMatches } = await resolveDeepScanSynthesis(this.deepScanReducerDeps(input, contract, log), {
                 succeeded,
                 adapters,
                 budgetStopped,
@@ -5205,7 +5230,8 @@ export class Orchestrator {
         const harnessLabel = attempts
             .map((a) => `${a.attemptId}:${a.harnessId}:${a.status}`)
             .join(", ");
-        store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${opts.mode})\n\n- Harnesses: ${harnessLabel}\n- Lifecycle: ${terminalFacts.lifecycle}${terminalFacts.reason ? ` (${terminalFacts.reason})` : ""}\n\n${report}\n`);
+        const secretLike = secretDiff.answerSecretLikeFinding(answerMatches);
+        store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${opts.mode})\n\n- Harnesses: ${harnessLabel}\n- Lifecycle: ${terminalFacts.lifecycle}${terminalFacts.reason ? ` (${terminalFacts.reason})` : ""}${secretDiff.summaryDisclosure(secretLike)}\n\n${report}\n`);
         const reportProducerAttemptId = opts.deepScan &&
             deepScanSynthesis?.status === "succeeded" &&
             deepScanSynthesis.reducer_attempt_id
@@ -5222,6 +5248,7 @@ export class Orchestrator {
                 mode: opts.mode,
                 intent: opts.intent,
                 read_only: true,
+                ...(secretLike ? { secret_like: secretLike } : {}),
             },
         });
         log.emit("work_product.emitted", { kind: "report", winner: reportProducerAttemptId });
@@ -5243,6 +5270,7 @@ export class Orchestrator {
                 reason: terminalFacts.reason,
                 phase: "executor",
                 failure_ref: "final/failure.yaml",
+                ...resumableTerminal(store, paths, attempts, true),
             });
         }
         else if (workVetoed) {
@@ -5250,6 +5278,7 @@ export class Orchestrator {
                 lifecycle: terminalFacts.lifecycle,
                 facts: terminalFacts,
                 reason: terminalFacts.reason,
+                ...resumableTerminal(store, paths, attempts, true),
             });
         }
         else {
@@ -5257,6 +5286,7 @@ export class Orchestrator {
                 lifecycle: terminalFacts.lifecycle,
                 facts: terminalFacts,
                 reason: terminalFacts.reason,
+                ...resumableTerminal(store, paths, attempts),
             });
         }
         return {