sortie-dogs 0.13.16 → 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.16](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.16)**
-· [Release notes](docs/release-v0.13.16.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.16
+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.16
+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.16**. 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.16-practical-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.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.16-practical-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.16-practical-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-mission.js

@@ -224,7 +224,11 @@ export class OperatorMissionRuntime {
             continuity: { notes: state.continuity?.notes, sources, progress: state.progress,
                 attempts: (state.attempts ?? []).map(({ runID, unitID, status, failure, resultClass, childSessionID }) => ({ run_id: runID, unit_id: unitID, status, failure, result_class: resultClass, session_id: childSessionID })),
                 execution: state.execution,
-                guidance: "Current original_requests/requirements govern; older plans remain historical. Continue from known decisions, environment, completed work and failures. Read snapshot JSON entries by message/call IDs only for a relevant gap. Recheck mutable facts when needed or conflicting; do not repeat unchanged setup/investigation merely because ownership changed. Historical results are not fresh formal validation or new authority." } };
+                source_authors: state.sourceAuthors ?? [],
+                corrections: (state.corrections ?? []).map(({ initialPrompt: _prompt, inlineReview: _inline, ...correction }) => correction),
+                retained_review: state.review ? { run_id: state.review.runID, verdict: state.review.verdict,
+                    mode: state.review.mode, author: state.review.child, result: state.review.result, self_recheck: state.review.selfRecheck } : null,
+                guidance: "Current original_requests/requirements govern; older plans remain historical. Continue from known decisions, environment, completed work, retained findings and failures. A new plan or author does not resolve findings or turn self-recheck into independent approval. Read snapshot JSON entries by message/call IDs only for a relevant gap. Recheck mutable facts when needed or conflicting; do not repeat unchanged setup/investigation/checks merely because ownership changed. Successful evidence remains with its actual author/call and input bindings; historical results are not new authority." } };
     }
     async load(file) {
         try {
@@ -804,14 +808,14 @@ export function missionPacket(mission, run) {
                 ? "Operator: use acceptance_summary to compare the submitted candidate with the verbatim original requests and actual evidence, inspect concrete gaps only, then complete_mission if satisfied. Do not routinely search archives or reread all source. Historical PASS is not current PASS. Report remaining evidence gaps; they are not a review PASS."
                 : run?.phase === "awaiting-acceptance" && mission.corrections?.some(item => item.runID === run.runID && item.status === "ready") && !reviewAccepted
                     ? mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.unresolvedFindings.length
-                        ? "Known Major/Medium findings remain after self-recheck. Call repair_review for the SAME original correction owner; do not dispatch another Reviewer or accept unresolved Medium. Retain original requirements and cumulative spend."
+                        ? "Known Major/Medium findings remain after self-recheck. Correct them with repair_review (reuse the author by default, or select an available Reviewer), or plan_units for Worker/direct execution. Retain findings, original requirements and cumulative spend; unresolved Medium is not acceptance."
                         : mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.residualMajor
                             ? "A concrete reachable Major risk remains after native author self-recheck. Call review_mission for a DIFFERENT Reviewer of the correction, retained findings and relevant impact; dispatch the exact returned Task if not already active. No fresh Worker or unchanged validation is required."
-                            : "Correction ready; call review_mission for the SAME native author to explicitly self-recheck the retained findings, relevant impact and original requirements. Only a concrete reachable Major risk remaining after self-recheck requires a DIFFERENT Reviewer. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
+                            : "Correction ready; reuse the native author for explicit self-recheck or select an independent Reviewer with review_mission when useful. Remaining authorized implementation may proceed with plan_units without acceptance. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
                     : mission.kind === "operation" && operationStatus === "running"
                         ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
                         : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
-                            ? "Correction validation or native execution failed. Call repair_review for a new admission in the SAME original Reviewer's native session; fix its own regression, rerun inherited checks and retain the commit/clean boundary and cumulative spend. Do not use ordinary retry, Rescue or a fresh Worker replan. Failure is never acceptance."
+                            ? "Correction validation or native execution failed. Reuse its context with repair_review, select another available Reviewer, or plan_units for Worker/direct correction. Retain findings, affected checks, requested delivery and cumulative spend. Failure is never acceptance."
                             : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
                                 ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
                                 : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
@@ -822,8 +826,8 @@ export function missionPacket(mission, run) {
                                 : run?.phase === "awaiting-acceptance" && !operationComplete
                                     ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
                                     : run?.phase === "awaiting-acceptance" ? (reviewAccepted
-                                        ? "Coordinator: review permits submission. Retain advisory review notes; do not repeat passed validation or review for evidence formatting. Operator performs final acceptance against the original requirements."
-                                        : "Coordinator: correct known Major/Medium findings, then obtain explicit native author self-recheck (different Reviewer only for residual concrete Major risk), or initial independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
+                                        ? "Coordinator: review permits submission, not completion of remaining implementation. Continue authorized remaining work with plan_units, or submit when the original requirements are met. Retain review notes; do not repeat passed validation or review for evidence formatting. Operator final acceptance remains separate."
+                                        : "Coordinator: correct known Major/Medium findings, then obtain native author self-recheck or useful independent review (required for concrete residual Major risk). Remaining authorized implementation can proceed without submission/acceptance. Operator compares all requirements with source/evidence before complete_mission.")
                                         : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */

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>>;
@@ -280,6 +285,8 @@ export declare class OperatorRuntime {
     private file;
     /** Exact persisted source for read-only status projections. */
     statePath(root: string): string;
+    /** Stable detail source for a settled run replaced by Mission replanning. */
+    replanArchivePath(state: OperatorState): string;
     /** Read-only lineage projection. Never imports archived evidence into current acceptance. */
     acceptanceHistory(state: OperatorState, missionRunIDs: readonly string[]): Promise<{
         status: "available" | "unavailable";
@@ -428,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

@@ -276,6 +276,10 @@ export class OperatorRuntime {
     }
     /** Exact persisted source for read-only status projections. */
     statePath(root) { return this.file(root); }
+    /** Stable detail source for a settled run replaced by Mission replanning. */
+    replanArchivePath(state) {
+        return `${this.file(state.rootSessionID)}.${state.runID}.${state.sequence}.archive`;
+    }
     /** Read-only lineage projection. Never imports archived evidence into current acceptance. */
     async acceptanceHistory(state, missionRunIDs) {
         const runs = [];
@@ -878,14 +882,12 @@ export class OperatorRuntime {
             if (!previous || previous.runID !== mission.replaceRunID || ["cancelled", "completed"].includes(previous.phase)) {
                 throw new Error("mission-replan-run-mismatch");
             }
-            if (previous.units.some(unit => unit.reviewerCorrection) && !mission.reviewerCorrection) {
-                throw new Error("mission-review-correction-owner-continuation-required");
-            }
-            if (previous.units.some(unit => unit.status === "running") || (previous.gitLifecycle !== null && !mission.reviewerCorrection))
+            // Completed correction/Git metadata is history, not a live writer lease.
+            // The plugin reconciles actual native executions before replacing this run.
+            if (previous.units.some(unit => unit.status === "running"))
                 throw new Error("mission-replan-worker-still-active");
-            const failedContinuation = previous.phase === "awaiting-decision" && previous.units.every(unit => unit.status === "failed" && unit.reviewerCorrection?.author === mission.reviewerCorrection?.author);
+            const failedContinuation = previous.phase === "awaiting-decision" && previous.units.every(unit => unit.status === "failed" && unit.reviewerCorrection);
             if (mission.reviewerCorrection && ((!failedContinuation && (previous.phase !== "awaiting-acceptance" || previous.units.some(unit => unit.status !== "succeeded"))) ||
-                previous.units.some(unit => unit.reviewerCorrection && unit.reviewerCorrection.author !== mission.reviewerCorrection.author) ||
                 plan.units.length !== 1 || plan.acceptance.length !== previous.acceptance.length ||
                 previous.acceptance.some((text, i) => text !== plan.acceptance[i]) ||
                 JSON.stringify(plan.acceptance_proof) !== JSON.stringify(previous.acceptanceProof) ||
@@ -1166,10 +1168,11 @@ export class OperatorRuntime {
                     await handle.close();
                 }
             }
-            if ((superseding || replanning) && previous) {
+            if ((superseding || replanning || previous?.phase === "completed") && previous) {
                 // A crash before the state switch may leave a checkpoint while the old run later advances.
                 // Sequence-qualified replan snapshots keep that history without blocking a subsequent correction.
-                const archive = `${this.file(root)}.${previous.runID}${replanning ? `.${previous.sequence}` : ""}.archive`;
+                const archive = replanning || previous.phase === "completed" ? this.replanArchivePath(previous)
+                    : `${this.file(root)}.${previous.runID}.archive`;
                 try {
                     const handle = await open(archive, "wx", 0o600);
                     created.push(archive);
@@ -1323,8 +1326,6 @@ export class OperatorRuntime {
             return args.task_id === expected.task_id && args.subagent_type === expected.subagent_type &&
                 args.description === expected.description && args.prompt === expected.prompt;
         }
-        if (unit.reviewerCorrection && (args.model !== undefined || args.variant !== undefined))
-            return false;
         if (unit.reviewerCorrection ? args.task_id !== unit.reviewerCorrection.author : args.task_id !== undefined && args.task_id !== "")
             return false;
         if (args.subagent_type !== unit.task.subagent_type || args.description !== unit.task.description)
@@ -2090,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")
@@ -2110,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/gate.d.ts

@@ -70,6 +70,10 @@ export declare function normalizeCommand(command: string): string;
 export declare function canonicalDeclaredValidationSequence(command: string, declared: ReadonlySet<string>): string | undefined;
 /** Preserve ordered members (including repeats) without splitting quoted text or substring matching. */
 export declare function canonicalDeclaredValidationMembers(command: string, declared: ReadonlySet<string> | readonly string[], occurrence?: number): string[] | undefined;
+/** Observation only, never shell authority. A successful native && chain can prove
+ * its exact declared tail after diagnostics/empty-directory cleanup. The caller
+ * must retain the real exit and the snapshot captured BEFORE the whole command. */
+export declare function canonicalObservedValidationMembers(command: string, declared: ReadonlySet<string> | readonly string[], occurrence?: number): string[] | undefined;
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export declare function isKnownReadOnlyTool(tool: string, args: unknown, additionalReadOnlyTools?: ReadonlySet<string>): boolean;
 /** Canonical scopes let sibling worker bindings reject equal or ancestor ownership. */

package/dist/plugin/gate.js

@@ -997,6 +997,40 @@ export function canonicalDeclaredValidationMembers(command, declared, occurrence
     };
     return sequence(0);
 }
+/** Observation only, never shell authority. A successful native && chain can prove
+ * its exact declared tail after diagnostics/empty-directory cleanup. The caller
+ * must retain the real exit and the snapshot captured BEFORE the whole command. */
+export function canonicalObservedValidationMembers(command, declared, occurrence = 0) {
+    const exact = canonicalDeclaredValidationMembers(command, declared, occurrence);
+    if (exact)
+        return exact;
+    const syntax = scanShellSyntax(command, "posix");
+    // Do not infer a tail through comments, expansions, redirection, subshells or
+    // shell-state changes. Unsupported observations leave existing authority alone.
+    if (syntax.unsafeExpansion || syntax.activeBrace || /[\\#$()<>`]/u.test(syntax.masked))
+        return undefined;
+    const segments = shellSegments(command, "posix").map(segment => segment.trim());
+    if (segments.length < 2 || segments.some(segment => !segment) ||
+        normalizeCommand(command) !== segments.map(normalizeCommand).join(" && "))
+        return undefined;
+    const identities = [...new Set(declared)];
+    for (let start = 1; start < segments.length; start++) {
+        const prefix = segments[start - 1];
+        // Never discard an ordered declared occurrence to find a later matching tail.
+        if (declaredCommandMatch(prefix, identities) !== undefined)
+            return undefined;
+        if (prefix.includes("`"))
+            return undefined;
+        const extracted = shellPaths(prefix, false);
+        const cleanup = /^rmdir(?:\s|$)/u.test(prefix);
+        if (extracted.ambiguous || extracted.remoteMutation || extracted.gitMutation || extracted.applies && !cleanup)
+            return undefined;
+        const members = canonicalDeclaredValidationMembers(segments.slice(start).join(" && "), declared, occurrence);
+        if (members)
+            return members;
+    }
+    return undefined;
+}
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export function isKnownReadOnlyTool(tool, args, additionalReadOnlyTools = new Set()) {
     const name = tool.toLowerCase();