sortie-dogs 0.13.17 → 0.13.18

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.13.17](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.17)**
-· [Release notes](docs/release-v0.13.17.md)
+**Current release: [v0.13.18](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.18)**
+· [Release notes](docs/release-v0.13.18.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -57,7 +57,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.17
+npm install --save-dev sortie-dogs@0.13.18
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -86,7 +86,7 @@ bridge. [Codex guide: SDK, permissions, progress, resume and manifest route](doc
 Use **OpenCode V2**. In the target project:
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.17
+npm install --save-dev sortie-dogs@0.13.18
 npx --no-install sortie-dogs init .
 ```
 
@@ -188,7 +188,7 @@ known expense. Official local evaluation and leaderboard acceptance are separate
 **8/23 (34.8%)**, versus v0.12.25's 7/23; all seven prior resolutions retained, no empty patches or
 official evaluation errors. [Fixed conditions, stopped-run accounting and costs](docs/benchmarks/swebench-lite-history.md#v0131-dev23-2026-09-30).
 
-All scores belong to their fixed candidates, **not v0.13.17**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.18**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -211,7 +211,7 @@ Install the desired package version and rerun **your host's** initializer:
 
 An OpenCode config-local bridge may resolve a separate package; npm-global update alone does not
 update it. [Global/update instructions](docs/configuration.md#global-availability).
-The current Mission asset marker is `0.13.17-handoff-continuity-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.18-direct-settlement-v1`; the unchanged Codex skill marker is
 `0.13.11-codex-skill-v2`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -227,7 +227,7 @@ follow the [manual removal guide](docs/uninstall.md), never delete the entire `.
   [SWE-bench history](docs/benchmarks/swebench-lite-history.md) · [Historical local case study](docs/benchmark-reference.md).
 - **Development:** [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md) ·
   [Windows tests](docs/windows-tests.md) · [Release routine](docs/release-batch.md).
-- **Releases:** [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
+- **Releases:** [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
   [v0.13.9](docs/release-v0.13.9.md) · [All GitHub releases](https://github.com/zufall-upon/Sortie-dogs/releases).
 
 ## Community

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.13.17-handoff-continuity-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.18-direct-settlement-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.13.17-handoff-continuity-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.18-direct-settlement-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/core/goal-bound.d.ts

@@ -111,6 +111,15 @@ export interface GoalTerminalReceipt {
 interface GoalEventBase {
     readonly at: string;
 }
+/** Host verification of an existing direct finish receipt, not a new execution. */
+export interface GoalDirectFinishRecovery {
+    readonly call_id: string;
+    readonly actor_session_id: string;
+    readonly finish_call_id: string;
+    readonly started_at: string;
+    readonly finished_at: string;
+    readonly validation_call_ids: readonly string[];
+}
 export interface GoalValidationRetryAuthorization {
     readonly authority: "operator-repair-validation-retry";
     readonly operator_run_id: string;
@@ -218,6 +227,7 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly unit_id: string;
     readonly previous_receipt_id: string;
     readonly evidence: readonly GoalEvidence[];
+    readonly direct_finish?: GoalDirectFinishRecovery;
 }) | (GoalEventBase & {
     readonly kind: "validation.admission";
     readonly goal_id: string;

package/dist/core/goal-bound.js

@@ -133,7 +133,7 @@ export function reduceGoalFlight(records) {
     let replanRevision = null;
     let legacyResetRevision = false;
     let previous = null;
-    const processDefects = new Map();
+    const recoverableSettlements = new Map();
     const unitCosts = new Map();
     const validationAdmissions = new Map();
     const validationSettlements = new Map();
@@ -160,7 +160,7 @@ export function reduceGoalFlight(records) {
                 session_ids: [event.origin_session_id] };
             replanRevision = null;
             legacyResetRevision = false;
-            processDefects.clear();
+            recoverableSettlements.clear();
             validationAdmissions.clear();
             validationSettlements.clear();
             reopenedValidationEvidence.clear();
@@ -255,8 +255,8 @@ export function reduceGoalFlight(records) {
                 unit_ids: addUnique(state.unit_ids, event.unit_id),
                 evidence_refs: event.evidence.reduce((refs, evidence) => addUnique(refs, evidence.evidence_id), state.evidence_refs),
                 satisfied_criteria: event.evidence.reduce((ids, evidence) => evidence.measurement.criterion_ids.reduce(addUnique, ids), state.satisfied_criteria) };
-            if (event.result_class === "process-defect" && event.evidence.length === 0 && event.disposition !== "cancelled") {
-                processDefects.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch });
+            if (event.evidence.length === 0 && event.disposition !== "succeeded") {
+                recoverableSettlements.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch, settlement: event });
             }
         }
         else if (event.kind === "unit.usage-reconciled") {
@@ -271,11 +271,24 @@ export function reduceGoalFlight(records) {
                     : costs.reduce((sum, item) => sum + item.cost, 0) };
         }
         else if (event.kind === "unit.evidence-reconciled") {
-            const old = processDefects.get(event.previous_receipt_id);
+            const old = recoverableSettlements.get(event.previous_receipt_id);
+            const direct = event.direct_finish, settled = old?.settlement;
+            const directFinish = direct !== undefined && text(direct.call_id) && direct.call_id.startsWith("direct-") &&
+                text(direct.actor_session_id) && text(direct.finish_call_id) && instant(direct.started_at) && instant(direct.finished_at) &&
+                Date.parse(direct.finished_at) >= Date.parse(direct.started_at) && Array.isArray(direct.validation_call_ids) && direct.validation_call_ids.length > 0 &&
+                direct.validation_call_ids.every(text) && settled?.native_session_id === direct.actor_session_id &&
+                settled.native_started_at !== undefined && Math.abs(Date.parse(settled.native_started_at) - Date.parse(direct.started_at)) <= 1000 &&
+                Math.abs(Date.parse(settled.at) - Date.parse(direct.finished_at)) <= 1000 &&
+                settled.reservation_id === goalFingerprint({ goal_id: event.goal_id, unit_id: event.unit_id, call_id: direct.call_id }) &&
+                settled.receipt_id === goalFingerprint({ call_id: direct.call_id,
+                    output: "Host-observed direct unit finished; controller session remains active." }) &&
+                (settled.disposition === "cancelled" && settled.result_class === "interrupted" ||
+                    settled.disposition === "failed" && ["process-defect", "acceptance"].includes(settled.result_class ?? ""));
+            const processDefect = direct === undefined && settled?.disposition !== "cancelled" && settled?.result_class === "process-defect";
             requireState(state.phase === "active" && state.receipt === null && old?.unitID === event.unit_id &&
-                old.revision === state.revision && old.epoch === state.scope_epoch && state.outstanding_reservations.length === 0, "transition", "Evidence reconciliation requires a current settled process defect.");
+                old.revision === state.revision && old.epoch === state.scope_epoch && state.outstanding_reservations.length === 0 && (processDefect || directFinish), "transition", "Evidence reconciliation requires a current settled process defect or verified direct finish defect.");
             requireState(event.evidence.length > 0 && event.evidence.every(entry => validGoalEvidence(entry, state) && entry.execution.units.includes(event.unit_id)), "evidence", "Reconciled evidence must retain the current goal and unit identity.");
-            processDefects.delete(event.previous_receipt_id);
+            recoverableSettlements.delete(event.previous_receipt_id);
             state = { ...state, evidence_refs: event.evidence.reduce((refs, evidence) => addUnique(refs, evidence.evidence_id), state.evidence_refs),
                 satisfied_criteria: event.evidence.reduce((ids, evidence) => evidence.measurement.criterion_ids.reduce(addUnique, ids), state.satisfied_criteria) };
         }

package/dist/core/operator-mission.d.ts

@@ -76,6 +76,13 @@ export interface MissionAttempt {
         code: string;
     };
     resultClass?: string;
+    /** Retained erroneous finish projection; the original goal receipt remains append-only. */
+    registrationRecovery?: {
+        at: string;
+        previousStatus: MissionAttempt["status"];
+        previousResultClass?: string;
+        previousFailure?: MissionAttempt["failure"];
+    };
     selectedModel?: string;
 }
 export interface MissionTerminalRescue {

package/dist/core/operator-runtime.d.ts

@@ -131,6 +131,11 @@ interface UnitState {
         actor: string;
         startedAt: string;
         finishedAt?: string;
+        registrationRecovery?: {
+            at: string;
+            previousStatus: "failed" | "cancelled";
+            previousResultClass: string | null;
+        };
         checks: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
         validationCwd?: Readonly<Record<string, string>>;
         validationRegisteredAt?: Readonly<Record<string, string>>;
@@ -430,7 +435,7 @@ export declare class OperatorRuntime {
     private repairValidationRetryBinding;
     canRetryRepairValidation(state: OperatorState): boolean;
     resumeRepairValidation(root: string, runID: string, authorize: (source: OperatorRepairValidationRetrySource) => Promise<void>): Promise<OperatorState>;
-    resume(root: string, runID: string, recovered: ReadonlyMap<string, readonly GoalEvidence[]>, unstarted?: ReadonlySet<string>): Promise<OperatorState>;
+    resume(root: string, runID: string, recovered: ReadonlyMap<string, readonly GoalEvidence[]>, unstarted?: ReadonlySet<string>, recoveredDirect?: ReadonlySet<string>): Promise<OperatorState>;
     requireAcceptanceRemediation(root: string, runID: string): Promise<OperatorState>;
     draftStatus(root: string): Promise<unknown | undefined>;
     completionGoalFingerprint(state: OperatorState): Promise<string>;

package/dist/core/operator-runtime.js

@@ -2091,16 +2091,17 @@ export class OperatorRuntime {
             return state;
         });
     }
-    resume(root, runID, recovered, unstarted = new Set()) {
+    resume(root, runID, recovered, unstarted = new Set(), recoveredDirect = new Set()) {
         return this.serial(root, async () => {
             const state = await this.required(root);
             if (state.contractRepair !== null)
                 throw new Error("operator-resume-contract-repair-required");
-            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(unit => unit.status === "running" || unit.status === "cancelled")) {
+            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(unit => unit.status === "running" ||
+                unit.status === "cancelled" && !recoveredDirect.has(unit.unit.id))) {
                 throw new Error("operator-resume-not-ready");
             }
             for (const unit of state.units) {
-                if (unit.status !== "failed")
+                if (unit.status !== "failed" && unit.status !== "cancelled")
                     continue;
                 if (unstarted.has(unit.unit.id)) {
                     if (unit.resultClass !== "process-defect" || unit.childSessionID !== null || state.decision !== "dispatch-admission-rejected")
@@ -2111,10 +2112,18 @@ export class OperatorRuntime {
                     continue;
                 }
                 const evidence = recovered.get(unit.unit.id);
+                const direct = recoveredDirect.has(unit.unit.id) && unit.directExecution?.actor === unit.childSessionID &&
+                    !!unit.directExecution.finishedAt && !!unit.callID && !!evidence?.length;
+                await this.verifyControls(unit);
                 const ids = new Set(evidence?.flatMap(item => item.measurement.criterion_ids) ?? []);
-                if (unit.resultClass !== "process-defect" || !evidence?.length || !unit.unit.acceptance_indices.every(index => state.acceptanceProof[index].some(id => ids.has(id)))) {
+                if (unit.resultClass !== "process-defect" && !direct || !evidence?.length || !unit.unit.acceptance_indices.every(index => state.acceptanceProof[index].some(id => ids.has(id)))) {
                     throw new Error("operator-resume-proof-incomplete");
                 }
+                if (unit.status === "cancelled" && !direct)
+                    throw new Error("operator-resume-proof-incomplete");
+                if (direct)
+                    unit.directExecution.registrationRecovery = { at: new Date().toISOString(),
+                        previousStatus: unit.status, previousResultClass: unit.resultClass };
                 unit.status = "succeeded";
                 unit.resultClass = "acceptance";
                 unit.evidence = evidence;

package/dist/core/run-flight-ledger.js

@@ -925,6 +925,14 @@ export class RunFlightLedger {
                 stored.reservation_id === event.reservation_id && stored.native_session_id === event.native_session_id &&
                 stored.cost_usd === event.cost_usd))
                 return reduceGoalFlight(records);
+            if (event.kind === "unit.evidence-reconciled" && event.direct_finish !== undefined) {
+                const existing = records.find(record => record.event.kind === "unit.evidence-reconciled" &&
+                    record.event.previous_receipt_id === event.previous_receipt_id)?.event;
+                if (existing?.kind === "unit.evidence-reconciled" && existing.goal_id === event.goal_id && existing.unit_id === event.unit_id &&
+                    goalFingerprint(existing.evidence) === goalFingerprint(event.evidence) &&
+                    goalFingerprint(existing.direct_finish) === goalFingerprint(event.direct_finish))
+                    return reduceGoalFlight(records);
+            }
             if (event.kind === "goal.accepted") {
                 const prior = records.find(({ event: stored }) => stored.kind === "goal.accepted" &&
                     stored.origin_user_message_id === event.origin_user_message_id);

package/dist/core/validation-budget.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { CONTRACT_TEXT_LIMITS } from "./contract-limits.js";
 export const VALIDATION_PROFILES = ["fast", "balanced", "assurance"];
 /** A real failed process can be rerun after setup repair without changing source or command identity. */
 export function retryableValidationFailure(outcome, exitCode) {
@@ -38,6 +39,7 @@ export function validationEvidenceState(events) {
     return { reusable: [...reusable], blocked: [...blocked] };
 }
 const id = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096;
+const commandText = (value) => typeof value === "string" && value.length > 0 && value.length <= CONTRACT_TEXT_LIMITS.command;
 const scopes = new Set(["static", "targeted", "related", "canonical", "full-suite", "full"]);
 const normalizedScope = (scope) => scope === "full" ? "canonical" : scope;
 export function validationOwner(scope) {
@@ -94,7 +96,7 @@ export function decideValidationBudget(request, state) {
     const environment = value.environment;
     const marginal = value.marginal_value;
     const valid = id(value.run_id) && id(value.operation_id) && id(value.source_snapshot) && id(value.candidate) &&
-        value.command.length > 0 && value.command.every(id) && scopes.has(value.scope) &&
+        value.command.length > 0 && value.command.every(commandText) && scopes.has(value.scope) &&
         environment !== null && typeof environment === "object" && id(environment.platform) && id(environment.arch) &&
         id(environment.runtime) && (environment.toolchain === undefined || id(environment.toolchain)) &&
         (value.owner === "worker" || value.owner === "coordinator") &&

package/dist/plugin/index.js

@@ -50,6 +50,7 @@ import { AdaptiveRemediationRuntime, AdaptiveRunFlightLineage } from "../core/ad
 import { DEFAULT_ADAPTIVE_REMEDIATION_MODEL, GitAdaptiveRemediationHost, OpenCodeAdaptiveRemediationProvider } from "./adaptive-remediation-host.js";
 import { collectRunMetrics, createSortieResult, createGoalReport, insertRunMetrics, insertSortieResult, replaceDoneTerminalStatus, replaceTerminalStatus, sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
 import { STABLE_RUNTIME_PROFILE } from "../core/runtime-profile.js";
+import { reviewerCorrectionValidationFresh } from "./mission-review.js";
 import { evidenceFromObservedExecution } from "../core/observed-goal-evidence.js";
 import { receiptBoundTerminalText } from "./receipt-presentation.js";
 import { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot, validatedSourceSnapshot, validationInputSnapshot } from "./protected-snapshot.js";
@@ -2369,11 +2370,15 @@ export const SortieDogsPlugin = async (input, options) => {
                 const failed = [...hostGoalExecutions.values()].find(execution => execution.root === reservation.root &&
                     execution.sessionID === child && execution.endedAt !== undefined && execution.outcome === "fail" &&
                     Date.parse(execution.startedAt) >= reservation.started - 1000);
-                await input.runtimeBridge?.onSerialSettlement?.({ rootSessionID: reservation.root, callID, unitID: settled.unit_id,
+                const result = { rootSessionID: reservation.root, callID, unitID: settled.unit_id,
                     ...(child ? { childSessionID: child } : {}), disposition: settled.disposition, evidence: settled.evidence,
-                    resultClass: settled.result_class ?? "process-defect", nativeOutcome: output.status === "error" || output.status === "cancelled" ? "failed" : "completed",
+                    resultClass: settled.result_class ?? "process-defect",
+                    ...(directEvidence !== undefined ? {} : { nativeOutcome: output.status === "error" || output.status === "cancelled" ? "failed" : "completed" }),
                     ...(settled.result_class === "acceptance" && failed ? { failure: { command: failed.command.slice(0, 8),
-                            outcome: "fail", exitCode: failed.exitCode ?? null } } : {}) });
+                            outcome: "fail", exitCode: failed.exitCode ?? null } } : {}) };
+                await input.runtimeBridge?.onSerialSettlement?.(result);
+                goalReservations.delete(callID);
+                return result;
             }
             goalReservations.delete(callID);
             return;
@@ -2405,7 +2410,10 @@ export const SortieDogsPlugin = async (input, options) => {
         // Revalidation can succeed for an already-satisfied criterion after a candidate change.
         // New criterion coverage controls progress accounting, not the validation disposition.
         const metadata = isRecord(output.metadata) ? output.metadata : undefined;
-        const child = childSessionID ? await input.client?.session?.get?.({ path: { id: childSessionID }, query: { directory: input.directory } }).catch(() => undefined) : undefined;
+        // A direct unit owns this invocation's checks, not the reusable controller
+        // conversation's last native Task outcome. Empty direct evidence still denotes
+        // direct failure; explicit cancellation/error below remains authoritative.
+        const child = directEvidence === undefined && childSessionID ? await input.client?.session?.get?.({ path: { id: childSessionID }, query: { directory: input.directory } }).catch(() => undefined) : undefined;
         const childInfo = isRecord(child) && "data" in child ? child.data : child;
         const childOutcome = isRecord(childInfo) ? childInfo.outcome : undefined;
         const terminalFailed = nativeOutcome === "failed" || metadata?.status === "error" || output.status === "error" ||
@@ -2432,7 +2440,7 @@ export const SortieDogsPlugin = async (input, options) => {
             evidence: settlementEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started),
             cost_usd: await nativeUnitCost(childSessionID, new Date(reservation.started).toISOString()),
             ...(childSessionID ? { native_session_id: childSessionID, native_started_at: new Date(reservation.started).toISOString() } : {}) });
-        await input.runtimeBridge?.onSerialSettlement?.({
+        const result = {
             rootSessionID: reservation.root, callID, unitID: reservation.unitID,
             ...(childSessionID === undefined ? {} : { childSessionID }),
             disposition: validated ? "succeeded" : interrupted ? "cancelled" : "failed",
@@ -2442,7 +2450,8 @@ export const SortieDogsPlugin = async (input, options) => {
                     command: failedAcceptanceExecution.command.slice(0, 8), outcome: "fail",
                     exitCode: failedAcceptanceExecution.exitCode ?? null,
                 } } : {}),
-        });
+        };
+        await input.runtimeBridge?.onSerialSettlement?.(result);
         goalReservations.delete(callID);
         if (childSessionID !== undefined) {
             goalValidationDefects.delete(childSessionID);
@@ -2451,6 +2460,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     hostGoalExecutions.delete(executionCallID);
             }
         }
+        return result;
     }
     async function settleRejectedGoalDispatch(rootSessionID, callID) {
         const reservation = goalReservations.get(callID);
@@ -2472,6 +2482,89 @@ export const SortieDogsPlugin = async (input, options) => {
         if (goal.acceptance_fingerprint !== request.goalFingerprint || goal.phase !== "active" || goal.receipt !== null || goal.outstanding_reservations.length) {
             throw new Error("operator-recovery-goal-not-ready");
         }
+        if (request.direct) {
+            const direct = request.direct;
+            const defect = [...snapshot.records].reverse().map(record => record.event).find(event => event.kind === "unit.settled" &&
+                event.unit_id === request.unitID && event.evidence.length === 0 && event.native_session_id === request.childSessionID &&
+                event.reservation_id === goalFingerprint({ goal_id: goal.goal_id, unit_id: request.unitID, call_id: direct.callID }) &&
+                event.receipt_id === goalFingerprint({ call_id: direct.callID,
+                    output: "Host-observed direct unit finished; controller session remains active." }));
+            if (defect?.kind !== "unit.settled" || Math.abs(Date.parse(defect.at) - Date.parse(direct.finishedAt)) > 1000) {
+                throw new Error("operator-recovery-direct-finish-receipt-missing");
+            }
+            const identity = await hostSessionIdentity(request.childSessionID);
+            if (!identity || request.childSessionID !== root && identity.parentID !== root &&
+                coordinatorRootForSession(request.childSessionID) !== root)
+                throw new Error("operator-recovery-direct-owner-mismatch");
+            const sessionAPI = input.client?.session;
+            const historyAPI = sessionAPI;
+            const messages = historyAPI?.reviewMessages ?? sessionAPI?.messages;
+            if (!messages)
+                throw new Error("operator-recovery-host-evidence-unavailable");
+            const historyRequest = { path: { id: request.childSessionID }, query: { directory: input.directory,
+                    notBefore: new Date(Date.parse(direct.startedAt) - 1000).toISOString() } };
+            const response = await messages.call(input.client.session, historyRequest);
+            const payload = isRecord(response) && "data" in response ? response.data : response;
+            if (!Array.isArray(payload))
+                throw new Error("operator-recovery-host-evidence-invalid");
+            const history = payload.filter(isRecord);
+            const parts = history.filter(message => isRecord(message.info) && message.info.role === "assistant" &&
+                message.info.sessionID === request.childSessionID).flatMap(message => Array.isArray(message.parts) ? message.parts.filter(isRecord) : []);
+            const finish = parts.find(part => part.type === "tool" && ["sortie_finish_direct_unit", `${runtimeProfile.toolPrefix}finish_direct_unit`].includes(String(part.tool)) &&
+                isRecord(part.state) && part.state.status === "completed" && isRecord(part.state.time) &&
+                typeof part.state.time.start === "number" && typeof part.state.time.end === "number" &&
+                part.state.time.start <= Date.parse(defect.at) && part.state.time.end >= Date.parse(defect.at));
+            if (!finish || typeof finish.callID !== "string")
+                throw new Error("operator-recovery-direct-finish-observation-missing");
+            if (parts.some(part => part.type === "tool" && ["cancel_operator", "cancel_mission"].some(name => part.tool === `sortie_${name}` || part.tool === `${runtimeProfile.toolPrefix}${name}`) && isRecord(part.state) && part.state.status === "completed" &&
+                isRecord(part.state.time) && typeof part.state.time.end === "number" && part.state.time.end >= Date.parse(direct.startedAt))) {
+                throw new Error("operator-recovery-direct-explicit-cancellation");
+            }
+            const checked = await reviewerCorrectionValidationFresh(direct.validation, request.childSessionID, history, Date.parse(direct.startedAt), direct.checks, input.directory, direct.directories, direct.registeredAt);
+            if (!checked.ready)
+                throw new Error(`operator-recovery-proof-unavailable-or-stale:${checked.reason}`);
+            const checks = direct.checks.filter(check => checked.matched?.some(item => item.callID === check.callID));
+            if (checks.some(check => check.dispatchCallID !== direct.callID || check.childSessionID !== request.childSessionID ||
+                resolve(input.directory, check.binding.manifest_path) !== resolve(request.manifestPath) ||
+                Date.parse(check.endedAt) > Date.parse(defect.at) + 1000))
+                throw new Error("operator-recovery-direct-check-identity-mismatch");
+            const evidence = checks.flatMap(check => observedHostGoalEvidence({ ...check, owner: "coordinator", outcome: "pass",
+                immutableRef: goalFingerprint({ direct_check: check }),
+                correction: { taskID: request.unitID, dispatchCallID: direct.callID, commands: check.command } }, goal, request.unitID));
+            for (const check of checks.filter(check => evidence.some(entry => check.command.includes(entry.execution.command[0])))) {
+                // The persisted host check already binds this exact native call to its
+                // Task/cwd/recipe. Its post-check validation recipe can be narrower than
+                // the admission snapshot; do not relabel or recompute that historical key.
+                const admission = snapshot.records.map(record => record.event).find(event => event.kind === "validation.admission" &&
+                    event.goal_id === goal.goal_id && event.operation_id === check.callID && event.decision === "ALLOW" &&
+                    Date.parse(event.at) >= Date.parse(direct.startedAt) - 1000 && Date.parse(event.at) <= Date.parse(check.endedAt) + 1000);
+                if (admission?.kind !== "validation.admission" || !snapshot.records.some(({ event }) => event.kind === "validation.settled" &&
+                    event.reservation_id === admission.reservation_id && event.operation_id === check.callID &&
+                    event.goal_id === goal.goal_id && event.evidence_key === admission.evidence_key && event.outcome === "passed" && event.exit_code === 0)) {
+                    throw new Error("operator-recovery-direct-validation-settlement-missing");
+                }
+            }
+            if (!evidence.length || evidence.some(entry => !validGoalEvidence(entry, goal)))
+                throw new Error("operator-recovery-proof-unavailable-or-stale");
+            const proof = { call_id: direct.callID, actor_session_id: request.childSessionID, finish_call_id: finish.callID,
+                started_at: direct.startedAt, finished_at: direct.finishedAt, validation_call_ids: checks.map(check => check.callID) };
+            const prior = snapshot.records.map(record => record.event).find(event => event.kind === "unit.evidence-reconciled" &&
+                event.previous_receipt_id === defect.receipt_id);
+            if (prior?.kind === "unit.evidence-reconciled") {
+                if (goalFingerprint(prior.direct_finish) !== goalFingerprint(proof) || goalFingerprint(prior.evidence) !== goalFingerprint(evidence)) {
+                    throw new Error("operator-recovery-direct-reconciliation-mismatch");
+                }
+                return prior.evidence;
+            }
+            // Recheck immediately before the existing append path; no reserve/admit/validation
+            // execution or spend settlement occurs when repairing this registration.
+            const final = await reviewerCorrectionValidationFresh(direct.validation, request.childSessionID, history, Date.parse(direct.startedAt), direct.checks, input.directory, direct.directories, direct.registeredAt);
+            if (!final.ready)
+                throw new Error(`operator-recovery-proof-unavailable-or-stale:${final.reason}`);
+            await ledger.appendGoal({ kind: "unit.evidence-reconciled", at: new Date().toISOString(), goal_id: goal.goal_id, unit_id: request.unitID,
+                previous_receipt_id: defect.receipt_id, evidence, direct_finish: proof });
+            return evidence;
+        }
         const defect = [...snapshot.records].reverse().map(record => record.event).find(event => event.kind === "unit.settled" &&
             event.unit_id === request.unitID && event.result_class === "process-defect" && !event.evidence.length);
         if (defect?.kind !== "unit.settled")
@@ -8290,10 +8383,13 @@ export const SortieDogsPlugin = async (input, options) => {
             const evidence = checks.flatMap(check => observedHostGoalEvidence({ ...check, owner: "coordinator",
                 outcome: check.exitCode === 0 ? "pass" : "fail", immutableRef: goalFingerprint({ direct_check: check }),
                 correction: { taskID: direct.taskID, dispatchCallID: direct.callID, commands: check.command } }, snapshot.state, direct.taskID));
-            await settleGoalDispatch(direct.callID, { output: "Host-observed direct unit finished; controller session remains active.",
+            const settled = await settleGoalDispatch(direct.callID, { output: "Host-observed direct unit finished; controller session remains active.",
                 metadata: { sessionId: actor } }, undefined, evidence);
+            if (!settled)
+                throw new Error("mission-direct-settlement-unavailable");
             await releaseWriteGate(actor);
             releaseSessionEnforcement(actor);
+            return settled;
         },
         releaseDirectUnit: async (actor) => {
             await releaseWriteGate(actor);

package/dist/plugin/profiled.js

@@ -240,8 +240,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             return observedMissionValidationSummary(validation, child, typeof nativeSession?.messages === "function"
                 ? () => session("messages", { path: { id: child }, query: { directory: input.directory } }) : undefined, notBefore, notBefore === undefined ? undefined : input.directory, direct?.unit.directExecution?.validationCwd ?? direct?.unit.unit.validation_cwd);
         }
-        async function reviewMessages(id) {
-            const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory } }));
+        async function reviewMessages(id, notBefore) {
+            const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory, ...(notBefore ? { notBefore } : {}) } }));
             return Array.isArray(result) ? result.filter(record) : [];
         }
         async function observedSessionModel(id) {
@@ -1814,107 +1814,171 @@ export function createProfiledPlugin(profile, assetVersion) {
                     ...(panel ? { return_report: panel,
                         return_report_instruction: "The host-authored receipt is retained in this tool result. Give the user a concise outcome and key checks; do not transcribe this card, recalculate it or request another model turn for presentation." } : {}) });
             } };
-        tools[resume] = { description: "Reconcile a finished process-defect unit from native host validation records and unchanged source. For the exact first validation-only contract-repair continuation process defect, unchanged durable controls/candidate and available validation budget permit one same-worker validation-only retry; the result includes the exact Task to invoke. Never reimplements a unit or resets implementation/goal spend.",
+        tools[resume] = { description: "Reconcile a finished process-defect or diagnosed direct finish-registration defect from retained native checks and currently unchanged source. Direct recovery preserves the same unit and all spend without rerunning checks; explicit cancellation, failed/incomplete/stale validation and ordinary Worker terminal decisions remain authoritative. For the exact first validation-only contract-repair continuation process defect, unchanged durable controls/candidate and available validation budget permit one same-worker validation-only retry. Never reimplements a unit or resets implementation/goal spend.",
             args: { run_id: stringSchema, acceptance_fingerprint: stringSchema }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
-                let state = await operators.required(context.sessionID);
-                if (state.runID !== args.run_id || state.acceptanceFingerprint !== args.acceptance_fingerprint || state.phase !== "awaiting-decision")
-                    throw new Error("operator-resume-identity-mismatch");
-                if (state.decision === "operator-acceptance-remediation-required") {
-                    throw new Error(state.repairGeneration === 1
-                        ? "operator-resume-unit-not-recoverable"
-                        : "operator-resume-acceptance-remediation-required");
-                }
-                async function finishedSession(id) {
-                    const statuses = payload(await session("status", { query: { directory: input.directory } }));
-                    const observed = record(statuses) ? statuses[id] : undefined;
-                    if (record(observed) && observed.type !== "idle")
-                        throw new Error("operator-resume-host-still-active");
-                    const history = await messages(id);
-                    const assistants = history.filter(message => (record(message.info) ? message.info.role : message.role) === "assistant");
-                    const last = assistants.at(-1), info = record(last?.info) ? last.info : last;
-                    const tail = history.at(-1), tailInfo = record(tail?.info) ? tail.info : tail;
-                    if (!info || tailInfo?.role !== "assistant" || (!isRecordTimeComplete(info) && info.finish !== "stop") || history.some(message => Array.isArray(message.parts) && message.parts.some(part => record(part) && part.type === "tool" && record(part.state) && ["pending", "running"].includes(String(part.state.status))))) {
-                        throw new Error("operator-resume-host-still-active");
+                return serializeDispatchTransition(context.sessionID, async () => {
+                    let state = await operators.required(context.sessionID);
+                    const replayDirect = new Set(state.units.filter(unit => unit.status === "succeeded" && !!unit.directExecution?.registrationRecovery)
+                        .map(unit => unit.unit.id));
+                    const replay = replayDirect.size > 0 && ["awaiting-acceptance", "awaiting-decision", "prepared"].includes(state.phase) &&
+                        !state.units.some(unit => ["failed", "cancelled", "running"].includes(unit.status));
+                    if (state.runID !== args.run_id || state.acceptanceFingerprint !== args.acceptance_fingerprint ||
+                        state.phase !== "awaiting-decision" && !replay)
+                        throw new Error("operator-resume-identity-mismatch");
+                    await operators.verifyContinuityControls(state);
+                    if (state.decision === "operator-acceptance-remediation-required" &&
+                        !state.units.some(unit => unit.status === "failed" && !!unit.directExecution?.finishedAt)) {
+                        throw new Error(state.repairGeneration === 1
+                            ? "operator-resume-unit-not-recoverable"
+                            : "operator-resume-acceptance-remediation-required");
                     }
-                }
-                function isRecordTimeComplete(info) { return record(info.time) && typeof info.time.completed === "number"; }
-                const delegate = state.operatorSessionID;
-                if (state.units.length > 1) {
-                    const owner = delegate ? await identity(delegate) : undefined;
-                    if (!delegate || owner?.parent !== context.sessionID || owner.role !== "dog-operator")
-                        throw new Error("operator-resume-delegate-owner-mismatch");
-                    await finishedSession(delegate);
-                    operatorParents.set(delegate, context.sessionID);
-                }
-                const goalFingerprint = await operators.completionGoalFingerprint(state);
-                await relinkRegisteredGoal(context.sessionID, state, goalFingerprint);
-                await control.assertActiveGoal(context.sessionID, goalFingerprint);
-                await restorePriorAcceptance(context.sessionID, state);
-                const recovered = new Map();
-                const unstarted = new Set();
-                for (const unit of state.units) {
-                    if (unit.status !== "failed")
-                        continue;
-                    const taskID = /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1];
-                    if (!taskID)
-                        throw new Error("operator-resume-task-id-missing");
-                    if (unit.resultClass === "process-defect" && unit.childSessionID === null && unit.callID && state.decision === "dispatch-admission-rejected") {
-                        const history = await messages(state.units.length > 1 ? delegate : context.sessionID);
-                        const matching = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) &&
-                            part.type === "tool" && ["task", "subagent"].includes(String(part.tool)) && part.callID === unit.callID && record(part.state) && part.state.status === "error" &&
-                            record(part.state.input) && operators.matchesRecordedWorkerTask(state, unit.unit.id, part.state.input) &&
-                            taskChildSessionID({ metadata: part.state.metadata, output: typeof part.state.output === "string" ? part.state.output : "" }) === undefined);
-                        if (matching.length !== 1 || !await control.hasNoGoalReservation(context.sessionID, taskID, unit.callID))
-                            throw new Error("operator-resume-unstarted-proof-missing");
-                        unstarted.add(unit.unit.id);
-                        continue;
+                    async function finishedSession(id, fullHistory = false, notBefore) {
+                        const statuses = payload(await session("status", { query: { directory: input.directory } }));
+                        const observed = record(statuses) ? statuses[id] : undefined;
+                        if (record(observed) && observed.type !== "idle")
+                            throw new Error("operator-resume-host-still-active");
+                        const history = fullHistory ? await reviewMessages(id, notBefore) : await messages(id);
+                        const assistants = history.filter(message => (record(message.info) ? message.info.role : message.role) === "assistant");
+                        const last = assistants.at(-1), info = record(last?.info) ? last.info : last;
+                        const tail = history.at(-1), tailInfo = record(tail?.info) ? tail.info : tail;
+                        if (!info || tailInfo?.role !== "assistant" || (!isRecordTimeComplete(info) && info.finish !== "stop") || history.some(message => Array.isArray(message.parts) && message.parts.some(part => record(part) && part.type === "tool" && record(part.state) && ["pending", "running"].includes(String(part.state.status))))) {
+                            throw new Error("operator-resume-host-still-active");
+                        }
                     }
-                    const child = unit.childSessionID ? await identity(unit.childSessionID) : undefined;
-                    if (unit.resultClass !== "process-defect" || !unit.childSessionID || child?.role !== "dog-worker" ||
-                        child.parent !== (state.units.length > 1 ? delegate : context.sessionID))
-                        throw new Error("operator-resume-unit-not-recoverable");
-                    await finishedSession(unit.childSessionID);
-                    try {
-                        recovered.set(unit.unit.id, await control.recoverUnitEvidence(context.sessionID, { unitID: taskID,
-                            childSessionID: unit.childSessionID, manifestPath: unit.manifestPath, manifestHash: unit.hashes[1], goalFingerprint }));
+                    function isRecordTimeComplete(info) { return record(info.time) && typeof info.time.completed === "number"; }
+                    const delegate = state.operatorSessionID;
+                    if (!replay && state.units.length > 1 && state.units.some(unit => unit.status === "failed" && !unit.directExecution)) {
+                        const owner = delegate ? await identity(delegate) : undefined;
+                        if (!delegate || owner?.parent !== context.sessionID || owner.role !== "dog-operator")
+                            throw new Error("operator-resume-delegate-owner-mismatch");
+                        await finishedSession(delegate);
+                        operatorParents.set(delegate, context.sessionID);
                     }
-                    catch (error) {
-                        if (!(error instanceof Error) || error.message.split(":", 1)[0] !== "operator-recovery-proof-unavailable-or-stale")
-                            throw error;
-                        if (!operators.canRetryRepairValidation(state)) {
-                            try {
-                                const remediation = await operators.requireAcceptanceRemediation(context.sessionID, state.runID);
-                                return JSON.stringify(await operatorPacket(remediation));
+                    const goalFingerprint = await operators.completionGoalFingerprint(state);
+                    await relinkRegisteredGoal(context.sessionID, state, goalFingerprint);
+                    await control.assertActiveGoal(context.sessionID, goalFingerprint);
+                    await restorePriorAcceptance(context.sessionID, state);
+                    const recovered = new Map();
+                    const recoveredDirect = new Set();
+                    const unstarted = new Set();
+                    for (const unit of state.units) {
+                        if (unit.status !== "failed" && unit.status !== "cancelled" && !(replay && replayDirect.has(unit.unit.id)))
+                            continue;
+                        const taskID = /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1];
+                        if (!taskID)
+                            throw new Error("operator-resume-task-id-missing");
+                        if (unit.directExecution) {
+                            const direct = unit.directExecution;
+                            const mission = await missions.required(context.sessionID);
+                            if (["cancelled", "completed"].includes(mission.phase) || mission.runID !== state.runID || !unit.callID ||
+                                !direct.finishedAt || direct.actor !== unit.childSessionID ||
+                                direct.actor !== (mission.coordinator ?? context.sessionID) && unit.reviewerCorrection?.author !== direct.actor) {
+                                throw new Error("operator-resume-direct-not-recoverable");
                             }
-                            catch (remediationError) {
-                                if (!(remediationError instanceof Error) || remediationError.message !== "operator-process-remediation-not-ready") {
-                                    throw remediationError;
+                            // A reusable root executes this very recovery tool. Its native conversation
+                            // need not end like a Worker Task; other actors still must be inactive.
+                            if (direct.actor !== context.sessionID)
+                                await finishedSession(direct.actor, true, direct.startedAt);
+                            recovered.set(unit.unit.id, await control.recoverUnitEvidence(context.sessionID, { unitID: taskID,
+                                childSessionID: direct.actor, manifestPath: unit.manifestPath, manifestHash: unit.hashes[1], goalFingerprint,
+                                direct: { callID: unit.callID, startedAt: direct.startedAt, finishedAt: direct.finishedAt,
+                                    checks: unit.reviewerCorrection?.checks ?? direct.checks, validation: unit.unit.validation,
+                                    directories: direct.validationCwd ?? unit.unit.validation_cwd,
+                                    registeredAt: unit.reviewerCorrection?.validationRegisteredAt ?? direct.validationRegisteredAt } }));
+                            recoveredDirect.add(unit.unit.id);
+                            continue;
+                        }
+                        if (unit.resultClass === "process-defect" && unit.childSessionID === null && unit.callID && state.decision === "dispatch-admission-rejected") {
+                            const history = await messages(state.units.length > 1 ? delegate : context.sessionID);
+                            const matching = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) &&
+                                part.type === "tool" && ["task", "subagent"].includes(String(part.tool)) && part.callID === unit.callID && record(part.state) && part.state.status === "error" &&
+                                record(part.state.input) && operators.matchesRecordedWorkerTask(state, unit.unit.id, part.state.input) &&
+                                taskChildSessionID({ metadata: part.state.metadata, output: typeof part.state.output === "string" ? part.state.output : "" }) === undefined);
+                            if (matching.length !== 1 || !await control.hasNoGoalReservation(context.sessionID, taskID, unit.callID))
+                                throw new Error("operator-resume-unstarted-proof-missing");
+                            unstarted.add(unit.unit.id);
+                            continue;
+                        }
+                        const child = unit.childSessionID ? await identity(unit.childSessionID) : undefined;
+                        if (unit.resultClass !== "process-defect" || !unit.childSessionID || child?.role !== "dog-worker" ||
+                            child.parent !== (state.units.length > 1 ? delegate : context.sessionID))
+                            throw new Error("operator-resume-unit-not-recoverable");
+                        await finishedSession(unit.childSessionID);
+                        try {
+                            recovered.set(unit.unit.id, await control.recoverUnitEvidence(context.sessionID, { unitID: taskID,
+                                childSessionID: unit.childSessionID, manifestPath: unit.manifestPath, manifestHash: unit.hashes[1], goalFingerprint }));
+                        }
+                        catch (error) {
+                            if (!(error instanceof Error) || error.message.split(":", 1)[0] !== "operator-recovery-proof-unavailable-or-stale")
+                                throw error;
+                            if (!operators.canRetryRepairValidation(state)) {
+                                try {
+                                    const remediation = await operators.requireAcceptanceRemediation(context.sessionID, state.runID);
+                                    return JSON.stringify(await operatorPacket(remediation));
+                                }
+                                catch (remediationError) {
+                                    if (!(remediationError instanceof Error) || remediationError.message !== "operator-process-remediation-not-ready") {
+                                        throw remediationError;
+                                    }
+                                    // A process defect without an authorized Git lifecycle has no committed remediation
+                                    // baseline. Preserve the failed run and return an explicit replacement route instead
+                                    // of turning this local routing limitation into a terminal tool exception.
+                                    const replacement = await operators.processReplacementRequired(context.sessionID, state.runID);
+                                    return JSON.stringify(processRemediationReplacementPacket(remediationError.message, operators.packet(replacement), cancel, prepare));
                                 }
-                                // A process defect without an authorized Git lifecycle has no committed remediation
-                                // baseline. Preserve the failed run and return an explicit replacement route instead
-                                // of turning this local routing limitation into a terminal tool exception.
-                                const replacement = await operators.processReplacementRequired(context.sessionID, state.runID);
-                                return JSON.stringify(processRemediationReplacementPacket(remediationError.message, operators.packet(replacement), cancel, prepare));
                             }
+                            const retried = await operators.resumeRepairValidation(context.sessionID, state.runID, source => control.authorizeOperatorContractRepairValidationRetry(context.sessionID, { ...source, declarationFingerprint: goalFingerprint }));
+                            await restorePriorAcceptance(context.sessionID, retried);
+                            return JSON.stringify({ run_id: retried.runID, acceptance_fingerprint: retried.acceptanceFingerprint,
+                                resumed: true, mode: "repair-validation-only", repair_validation_attempt: 2,
+                                task: retried.units.length === 1 ? operators.nextWorkerTask(retried) : operators.dispatchTask(retried) });
                         }
-                        const retried = await operators.resumeRepairValidation(context.sessionID, state.runID, source => control.authorizeOperatorContractRepairValidationRetry(context.sessionID, { ...source, declarationFingerprint: goalFingerprint }));
-                        await restorePriorAcceptance(context.sessionID, retried);
-                        return JSON.stringify({ run_id: retried.runID, acceptance_fingerprint: retried.acceptanceFingerprint,
-                            resumed: true, mode: "repair-validation-only", repair_validation_attempt: 2,
-                            task: retried.units.length === 1 ? operators.nextWorkerTask(retried) : operators.dispatchTask(retried) });
                     }
-                }
-                await control.assertActiveGoal(context.sessionID, goalFingerprint);
-                const resumed = await operators.resume(context.sessionID, state.runID, recovered, unstarted);
-                await restorePriorAcceptance(context.sessionID, resumed);
-                if (resumed.phase === "awaiting-acceptance")
-                    return JSON.stringify(operators.packet(resumed));
-                const remaining = resumed.units.filter(unit => unit.status === "pending").length;
-                control.enableUnits(context.sessionID, remaining);
-                return JSON.stringify({ run_id: resumed.runID, acceptance_fingerprint: resumed.acceptanceFingerprint,
-                    resumed: true, remaining_units: remaining,
-                    task: resumed.units.length === 1 ? operators.nextWorkerTask(resumed) : operators.dispatchTask(resumed) });
+                    await control.assertActiveGoal(context.sessionID, goalFingerprint);
+                    const resumed = replay ? state : await operators.resume(context.sessionID, state.runID, recovered, unstarted, recoveredDirect);
+                    if (recoveredDirect.size)
+                        await missions.update(context.sessionID, mission => {
+                            if (mission.runID !== resumed.runID || ["completed", "cancelled"].includes(mission.phase))
+                                throw new Error("operator-resume-direct-mission-changed");
+                            for (const unit of resumed.units.filter(unit => recoveredDirect.has(unit.unit.id))) {
+                                const attempt = mission.attempts?.find(attempt => attempt.callID === unit.callID);
+                                if (attempt && !attempt.registrationRecovery) {
+                                    attempt.registrationRecovery = { at: unit.directExecution.registrationRecovery.at, previousStatus: attempt.status,
+                                        previousResultClass: attempt.resultClass, previousFailure: attempt.failure };
+                                    attempt.status = "succeeded";
+                                    attempt.resultClass = "acceptance";
+                                    delete attempt.failure;
+                                }
+                                if ([...mission.progress].reverse().find(item => item.unit === `${resumed.runID}/${unit.unit.id}`)?.status !== "succeeded") {
+                                    mission.progress.push({ unit: `${resumed.runID}/${unit.unit.id}`, title: unit.unit.title, status: "succeeded", at: new Date().toISOString() });
+                                }
+                                const correction = mission.corrections?.find(item => item.runID === resumed.runID && item.author === unit.directExecution?.actor);
+                                if (correction)
+                                    correction.status = "ready";
+                            }
+                        });
+                    await restorePriorAcceptance(context.sessionID, resumed);
+                    if (recoveredDirect.size)
+                        return JSON.stringify({
+                            ...compactMissionEvidence(missionPacket(await missions.required(context.sessionID), resumed), resumed, context.sessionID),
+                            recovered_direct_units: [...recoveredDirect],
+                            next_action: "The same direct unit's finish registration is reconciled from currently fresh native checks, without a new unit or check rerun. Retain the original erroneous receipt and cumulative spend. " +
+                                (resumed.phase === "awaiting-decision" ? `The recorded boundary decision remains pending: ${resumed.decision}. No replacement Task is admitted. ` :
+                                    resumed.phase === "prepared" ? "Remaining planned units are still pending under the existing authorization and cumulative budget. " : "") +
+                                "Latest-change Review and individual product acceptance remain pending; this recovery is not acceptance, Go or completion."
+                        });
+                    if (resumed.phase === "awaiting-acceptance") {
+                        return JSON.stringify(operators.packet(resumed));
+                    }
+                    if (resumed.phase === "awaiting-decision")
+                        return JSON.stringify(operators.packet(resumed));
+                    const remaining = resumed.units.filter(unit => unit.status === "pending").length;
+                    control.enableUnits(context.sessionID, remaining);
+                    return JSON.stringify({ run_id: resumed.runID, acceptance_fingerprint: resumed.acceptanceFingerprint,
+                        resumed: true, remaining_units: remaining,
+                        task: resumed.units.length === 1 ? operators.nextWorkerTask(resumed) : operators.dispatchTask(resumed) });
+                });
             } };
         tools[beginProposal] = { description: `Root-only: freeze original ordered requirements and grant one bounded read-only proposal investigation to dogs-coordinator. The result contains one exact short Task reference; pass task.subagent_type, task.description, and task.prompt byte-for-byte without appending or paraphrasing. The native parent retains that reference; the host expands it only inside the directly claimed proposal child. ${OPERATOR_INTENT_CONTRACT}`,
             args: { intent_json: intentSchema }, execute: async (args, context) => {
@@ -2140,8 +2204,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                             next_action: "Correct the actual failure or run the missing/affected checks in this same session, then finish_direct_unit. Preserve successful current evidence; do not dispatch a validation-only Worker." });
                     // A resumed correction Task settles at its native terminal, not at this
                     // advisory completion call. Inline/direct execution uses its existing finish path.
-                    if (direct.unit.directExecution)
-                        await control.finishDirectUnit(root, context.sessionID, (direct.unit.reviewerCorrection?.checks ?? direct.unit.directExecution.checks).filter(check => checks.matched?.some(item => item.callID === check.callID)));
+                    if (direct.unit.directExecution) {
+                        const settled = await control.finishDirectUnit(root, context.sessionID, (direct.unit.reviewerCorrection?.checks ?? direct.unit.directExecution.checks).filter(check => checks.matched?.some(item => item.callID === check.callID)));
+                        const saved = (await operators.required(root)).units.find(unit => unit.callID === direct.unit.callID);
+                        if (settled.disposition !== "succeeded" || !settled.evidence.length || saved?.status !== "succeeded" || !saved.evidence.length) {
+                            const run = await operators.required(root);
+                            return JSON.stringify({ ...compactMissionEvidence(missionPacket(await missions.required(root), run), run, root),
+                                direct_settlement: { disposition: settled.disposition, result_class: settled.resultClass, evidence_count: settled.evidence.length },
+                                next_action: "Direct unit is not validated: retain its actual settlement, native checks, current source and cumulative spend. Inspect the recorded cancellation/failure or use resume_operator for a diagnosed finish-registration defect; do not repeat passed checks or create a replacement unit just to repair registration. Review and Mission acceptance remain pending." });
+                        }
+                    }
                     if (direct.unit.reviewerCorrection)
                         return JSON.stringify({ status: "correction-validated",
                             execution: "same-native-task", validation: direct.unit.unit.validation,

package/dist/plugin/runtime-bridge.d.ts

@@ -203,6 +203,15 @@ export interface RuntimeBridge {
             manifestPath: string;
             manifestHash: string;
             goalFingerprint: string;
+            direct?: {
+                callID: string;
+                startedAt: string;
+                finishedAt: string;
+                checks: readonly ReviewerCorrectionCheck[];
+                validation: readonly string[];
+                directories?: Readonly<Record<string, string>>;
+                registeredAt?: Readonly<Record<string, string>>;
+            };
         }): Promise<readonly GoalEvidence[]>;
         completionReadiness(rootSessionID: string): Promise<import("./goal-completion.js").CompletionReadiness>;
         missionWorkerTerminal(rootSessionID: string, terminal: MissionWorkerTerminalRecord, writeScopes: readonly string[]): Promise<{
@@ -212,7 +221,7 @@ export interface RuntimeBridge {
         restoreReviewerCorrectionChild(rootSessionID: string, childSessionID: string, callID: string, taskID: string): Promise<void>;
         activateMissionWorker(rootSessionID: string, childSessionID: string, handoffPath: string, admission: MissionImplementationAdmission): Promise<void>;
         activateDirectUnit(rootSessionID: string, actorSessionID: string, prompt: string, handoffPath: string): Promise<void>;
-        finishDirectUnit(rootSessionID: string, actorSessionID: string, checks: readonly ReviewerCorrectionCheck[]): Promise<void>;
+        finishDirectUnit(rootSessionID: string, actorSessionID: string, checks: readonly ReviewerCorrectionCheck[]): Promise<SerialDispatchSettlement>;
         /** Settle an unfinished direct unit against its actual actor, never a fabricated child Task. */
         failDirectUnit(rootSessionID: string, actorSessionID: string): Promise<void>;
         releaseDirectUnit(actorSessionID: string): Promise<void>;

package/dist/plugin/v2.js

@@ -110,11 +110,12 @@ function legacyMessage(value, session, agent) {
             return converted === undefined ? [] : [converted];
         }) };
 }
-async function legacyMessages(context, id, paginated) {
+async function legacyMessages(context, id, paginated, notBefore) {
     const list = paginated ?? (context.message ? (input) => context.message.list(input) : undefined);
     const [info, history] = await Promise.all([
         context.session.get({ sessionID: id }).catch(() => undefined),
-        list ? nativePages(cursor => list({ sessionID: id, limit: 100, ...(cursor ? { cursor } : { order: "asc" }) }))
+        list ? nativePages(cursor => list({ sessionID: id, limit: 100,
+            ...(cursor ? { cursor } : { order: notBefore === undefined ? "asc" : "desc" }) }), notBefore)
             : context.session.context({ sessionID: id }),
     ]);
     const agent = record(info) ? string(info.agent) : undefined;
@@ -123,17 +124,24 @@ async function legacyMessages(context, id, paginated) {
         return converted === undefined ? [] : [converted];
     });
 }
-async function nativePages(fetch) {
+async function nativePages(fetch, notBefore) {
     const items = [], seen = new Set();
     let cursor;
-    for (let page = 0; page < 100; page += 1) {
+    for (let page = 0; notBefore !== undefined || page < 100; page += 1) {
         const result = await fetch(cursor);
         if (!record(result) || !Array.isArray(result.data) || !record(result.cursor))
             throw new Error("v2-history-page-invalid");
         items.push(...result.data);
+        // Retain the whole boundary page: a message created before admission can
+        // contain tools that started after it. The check verifier applies its own
+        // exact native-start cutoff. Do not scan decades of unrelated controller
+        // history or reject a known unit window at the general full-history cap.
+        if (notBefore !== undefined && result.data.some(message => record(message) && record(message.time) &&
+            typeof message.time.created === "number" && message.time.created < notBefore))
+            return items.reverse();
         const next = string(result.cursor.next);
         if (!next)
-            return items;
+            return notBefore === undefined ? items : items.reverse();
         if (seen.has(next))
             throw new Error("v2-history-cursor-repeated");
         seen.add(next);
@@ -160,7 +168,9 @@ function legacyClient(context) {
         },
         reviewMessages: async (request) => {
             const id = sessionID(request);
-            return { data: id === undefined ? [] : await legacyMessages(context, id, context.message ? input => context.message.list(input) : reviewList) };
+            const query = record(request) && record(request.query) ? request.query : undefined;
+            const requestedStart = typeof query?.notBefore === "string" ? Date.parse(query.notBefore) : undefined;
+            return { data: id === undefined ? [] : await legacyMessages(context, id, context.message ? input => context.message.list(input) : reviewList, Number.isFinite(requestedStart) ? requestedStart : undefined) };
         },
         reviewExecution: async (request) => {
             const id = sessionID(request);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.13.17",
+  "version": "0.13.18",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",