sortie-dogs 0.16.1 → 0.16.3

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.16.1-review-git-boundary-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.3-strategy-admission-recovery-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";
 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.16.1-review-git-boundary-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.3-strategy-admission-recovery-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

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

@@ -273,6 +273,14 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly goal_id: string;
     readonly revision: number;
     readonly reason: "no-progress";
+}) | (GoalEventBase & {
+    readonly kind: "goal.validation-registered";
+    readonly goal_id: string;
+    readonly reservation_id: string;
+    readonly unit_id: string;
+    readonly criterion_id: string;
+    readonly command: string;
+    readonly registered_at: string;
 }) | (GoalEventBase & {
     readonly kind: "goal.terminal";
     readonly goal_id: string;
@@ -309,6 +317,12 @@ export interface GoalFlightState {
     readonly delivery: GoalDeliveryMode | null;
     readonly budget: GoalBudget | null;
     readonly acceptance_contract: GoalAcceptanceContract | null;
+    /** Native registration metadata only; the acceptance contract and its fingerprint stay frozen. */
+    readonly validation_registrations?: Readonly<Record<string, {
+        readonly unit_id: string;
+        readonly command: string;
+        readonly registered_at: string;
+    }>>;
     readonly consumed_units: number;
     readonly consumed_time_ms: number | null;
     readonly consumed_cost_usd: number | null;
@@ -355,6 +369,7 @@ export declare function selectGoalDelivery(input: {
     readonly irreversible_or_major_scope: boolean;
     readonly explicit_mode?: GoalDeliveryMode;
 }): GoalDeliveryMode;
-export declare function validGoalEvidence(value: GoalEvidence, state: Pick<GoalFlightState, "goal_id" | "revision" | "scope_epoch" | "acceptance_fingerprint" | "acceptance_contract">): boolean;
+export declare const goalValidationCommand: (state: Pick<GoalFlightState, "validation_registrations">, criterion: GoalAcceptanceCriterion) => string | undefined;
+export declare function validGoalEvidence(value: GoalEvidence, state: Pick<GoalFlightState, "goal_id" | "revision" | "scope_epoch" | "acceptance_fingerprint" | "acceptance_contract" | "validation_registrations">): boolean;
 export declare function reduceGoalFlight(records: readonly GoalFlightEventRecord[]): GoalFlightState;
 export {};

package/dist/core/goal-bound.js

@@ -51,6 +51,7 @@ function validAcceptanceContract(value) {
 function sameStrings(left, right) {
     return left.length === right.length && left.every((value, index) => value === right[index]);
 }
+export const goalValidationCommand = (state, criterion) => state.validation_registrations?.[criterion.criterion_id]?.command ?? criterion.validation_command;
 export function validGoalEvidence(value, state) {
     if (typeof value !== "object" || value === null || typeof value.measurement !== "object" || value.measurement === null ||
         typeof value.identity !== "object" || value.identity === null || typeof value.execution !== "object" || value.execution === null ||
@@ -100,8 +101,11 @@ export function validGoalEvidence(value, state) {
             (criterion.candidate_binding === "current-protected"
                 ? protectedBindingValid && HASH.test(value.identity.candidate) && (dockerWorkspace === undefined || dockerWorkspace.candidate === value.identity.candidate)
                 : criterion.candidate === value.identity.candidate) &&
-            (criterion.validation_command === undefined ||
-                (value.execution.command.length === 1 && value.execution.command[0] === criterion.validation_command)) &&
+            (goalValidationCommand(state, criterion) === undefined ||
+                (value.execution.command.length === 1 && value.execution.command[0] === goalValidationCommand(state, criterion))) &&
+            (!state.validation_registrations?.[criterion.criterion_id] ||
+                value.execution.units.includes(state.validation_registrations[criterion.criterion_id].unit_id) &&
+                    Date.parse(value.execution.started_at) >= Date.parse(state.validation_registrations[criterion.criterion_id].registered_at)) &&
             criterion.fixture === value.identity.fixture &&
             criterion.proof_scope === value.proof_scope && criterion.expected_outcome === value.execution.outcome);
     return text(value.evidence_id) && value.goal_id === state.goal_id && value.goal_revision === state.revision &&
@@ -193,7 +197,7 @@ export function reduceGoalFlight(records) {
                 selected_agent: event.selected_agent, delivery: event.delivery, budget: event.budget,
                 validation_budget: { ...state.validation_budget,
                     limit: state.validation_budget.limit === null ? null : Math.max(state.validation_budget.limit, state.validation_budget.consumed, event.budget.max_units) },
-                acceptance_contract: event.acceptance_contract,
+                acceptance_contract: event.acceptance_contract, validation_registrations: undefined,
                 session_ids: addUnique(state.session_ids, event.session_id), phase: "active", stop_reason: null,
                 receipt: null, tickets: [], ...(event.reset_no_progress === true
                     ? { no_progress_results: 0, replan_required: false, replan_used: false }
@@ -204,6 +208,14 @@ export function reduceGoalFlight(records) {
             if (validationAdmissionLimit !== null)
                 validationAdmissionLimit = Math.max(event.budget.max_units, state.validation_budget.consumed);
         }
+        else if (event.kind === "goal.validation-registered") {
+            requireState(state.phase === "active" && state.outstanding_reservations.some(item => item.reservation_id === event.reservation_id && item.unit_id === event.unit_id) &&
+                state.acceptance_contract?.criteria.some(item => item.criterion_id === event.criterion_id) === true &&
+                commandText(event.command) && instant(event.registered_at) && Date.parse(event.registered_at) <= Date.parse(event.at), "transition", "Validation registration requires the same active reserved unit and a current criterion.");
+            state = { ...state, validation_registrations: { ...state.validation_registrations,
+                    [event.criterion_id]: { unit_id: event.unit_id, command: event.command, registered_at: event.registered_at } },
+                satisfied_criteria: state.satisfied_criteria.filter(id => id !== event.criterion_id) };
+        }
         else if (event.kind === "ticket.issued") {
             requireState(state.phase === "active" && event.revision === state.revision && event.scope_epoch === state.scope_epoch &&
                 event.origin_user_message_id === state.latest_user_message_id && event.sequence === state.tickets.length + 1 &&

package/dist/core/observed-goal-evidence.d.ts

@@ -15,4 +15,4 @@ export interface ObservedGoalExecution {
 }
 /** One host execution can exercise several independently declared criteria.
  * Preserve each measurement identity instead of dropping all heterogeneous ones. */
-export declare function evidenceFromObservedExecution(execution: ObservedGoalExecution, state: Pick<GoalFlightState, "goal_id" | "revision" | "scope_epoch" | "acceptance_fingerprint" | "acceptance_contract">, unitID: string): GoalEvidence[];
+export declare function evidenceFromObservedExecution(execution: ObservedGoalExecution, state: Pick<GoalFlightState, "goal_id" | "revision" | "scope_epoch" | "acceptance_fingerprint" | "acceptance_contract" | "validation_registrations">, unitID: string): GoalEvidence[];

package/dist/core/observed-goal-evidence.js

@@ -1,4 +1,4 @@
-import { goalFingerprint } from "./goal-bound.js";
+import { goalFingerprint, goalValidationCommand } from "./goal-bound.js";
 /** One host execution can exercise several independently declared criteria.
  * Preserve each measurement identity instead of dropping all heterogeneous ones. */
 export function evidenceFromObservedExecution(execution, state, unitID) {
@@ -6,7 +6,7 @@ export function evidenceFromObservedExecution(execution, state, unitID) {
         return [];
     // Canonical requested-full proof is coordinator-owned and must never be manufactured from a
     // child shell result. The caller derives owner from the observed host session lineage.
-    const matching = state.acceptance_contract?.criteria.filter(criterion => criterion.validation_command === execution.command[0] && criterion.expected_outcome === "pass" &&
+    const matching = state.acceptance_contract?.criteria.filter(criterion => goalValidationCommand(state, criterion) === execution.command[0] && criterion.expected_outcome === "pass" &&
         (criterion.proof_scope !== "requested-full" || execution.owner === "coordinator")) ?? [];
     const groups = new Map();
     for (const criterion of matching) {

package/dist/core/operator-mission.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
 import { join, resolve, win32 } from "node:path";
 import { normalizeExecutionScope } from "./path.js";
-import { parseOperatorPlan } from "./operator-runtime.js";
+import { parseOperatorPlan, unitValidation } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
 import { normalizeCommand, shellCommandBase, shellCommandWords } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
@@ -859,7 +859,7 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
         // Settled proof already records these commands. Do not fetch the same native
         // history again merely to render acceptance; freshness is checked separately.
         const proofs = unit.evidence ?? [];
-        if (unit.status === "succeeded" && unit.unit.validation.every(command => proofs.some(proof => proof.execution.exit_code === 0 && proof.execution.outcome === "pass" &&
+        if (unit.status === "succeeded" && unitValidation(unit).every(command => proofs.some(proof => proof.execution.exit_code === 0 && proof.execution.outcome === "pass" &&
             proof.execution.command.includes(command)))) {
             return { ...provenance, status: "recorded-formal-evidence",
                 evidence_ids: proofs.map(proof => proof.evidence_id),
@@ -868,7 +868,7 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
         try {
             if (!observe || !unit.childSessionID)
                 throw new Error("native-worker-history-unavailable");
-            return { ...provenance, status: "available", observations: await observe(unit.unit.validation, unit.childSessionID, unit.directExecution ? Date.parse(unit.directExecution.startedAt) :
+            return { ...provenance, status: "available", observations: await observe(unitValidation(unit), unit.childSessionID, unit.directExecution ? Date.parse(unit.directExecution.startedAt) :
                     unit.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? item.state.createdAt) : undefined) };
         }
         catch (error) {
@@ -942,7 +942,7 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
                 handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
-                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
+                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unitValidation(unit),
                 normal_remediation_used: unit.normalRemediationUsed ?? false,
                 ...(unit.failure ? { failure: { outcome: unit.failure.outcome, exit_code: unit.failure.exitCode } } : {}),
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),

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

@@ -127,6 +127,13 @@ interface UnitState {
         validationRegisteredAt?: Readonly<Record<string, string>>;
     };
     evidence: readonly GoalEvidence[];
+    /** Effective check registration, separate from the immutable admitted contract. */
+    validationRegistration?: {
+        validation: readonly string[];
+        cwd: Readonly<Record<string, string>>;
+        registeredAt: Readonly<Record<string, string>>;
+        checks: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
+    };
     /** Implementation in the existing controller session, without a native child Task. */
     directExecution?: {
         actor: string;
@@ -138,6 +145,7 @@ interface UnitState {
             previousResultClass: string | null;
         };
         checks: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
+        validation?: readonly string[];
         validationCwd?: Readonly<Record<string, string>>;
         validationRegisteredAt?: Readonly<Record<string, string>>;
     };
@@ -283,6 +291,10 @@ export interface OperatorProgress {
 export declare function cancelledMissionRetainsAcceptance(state: OperatorState): boolean;
 export declare function operatorGitPathAuthorized(path: string, scopes: readonly string[], platform?: NodeJS.Platform): boolean;
 export declare function parseOperatorPlan(value: unknown, scopeFormat?: "repository" | "execution"): OperatorPlan;
+export declare const unitValidation: (unit: OperatorState["units"][number]) => readonly string[];
+export declare const unitValidationCwd: (unit: OperatorState["units"][number]) => Readonly<Record<string, string>> | undefined;
+/** Strip only the owning unit's registration fields when comparing its frozen plan. */
+export declare function directValidationRegistrationPlanHash(state: OperatorState, plan: OperatorPlan, unitID: string): string;
 /** Root-owned durable queue. It never executes code, changes acceptance, or accepts a candidate. */
 export declare class OperatorRuntime {
     readonly profile: RuntimeProfile;
@@ -332,7 +344,10 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean, context?: Record<string, unknown>): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean, context?: Record<string, unknown>, terminalTaskCalls?: {
+        runID: string;
+        callIDs: readonly string[];
+    }): Promise<OperatorState>;
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root: string, runID: string, raw: unknown, dispatcher?: {
         sessionID: string;
@@ -368,6 +383,8 @@ export declare class OperatorRuntime {
     }>;
     private matchesWorkerTask;
     matchesRecordedWorkerTask(state: OperatorState, unitID: string, args: unknown): boolean;
+    /** Historical comparison only: cancellation revoked the admission generation. */
+    matchesCancelledWorkerTask(state: OperatorState, unitID: string, args: unknown): boolean;
     admitOperator(root: string, callID: string, args: unknown): Promise<OperatorTask>;
     private admitOperatorOnce;
     bindOperator(root: string, sessionID: string, prompt: string): Promise<void>;

package/dist/core/operator-runtime.js

@@ -260,6 +260,23 @@ export function parseOperatorPlan(value, scopeFormat = "repository") {
     expandGoalDeclaration(value.goal_declaration);
     return { ...value, acceptance: normalizeAcceptanceCriteria(value.acceptance) };
 }
+export const unitValidation = (unit) => unit.validationRegistration?.validation ?? unit.unit.validation;
+export const unitValidationCwd = (unit) => unit.validationRegistration?.cwd ?? unit.directExecution?.validationCwd ?? unit.unit.validation_cwd;
+/** Strip only the owning unit's registration fields when comparing its frozen plan. */
+export function directValidationRegistrationPlanHash(state, plan, unitID) {
+    const original = state.units.find(item => item.unit.id === unitID)?.unit;
+    const proposed = plan.units.find(item => item.id === unitID);
+    const criteria = plan.goal_declaration.criteria;
+    const goal = Array.isArray(criteria) ? { ...plan.goal_declaration, criteria: criteria.map(criterion => record(criterion) && criterion.criterion_id === unitID && criterion.validation_command === proposed?.validation.at(-1)
+            ? { ...criterion, validation_command: original?.validation.at(-1) } : criterion) } : plan.goal_declaration;
+    return hash(JSON.stringify({ ...plan, goal_declaration: goal, units: plan.units.map((next, index) => {
+            const prior = state.units[index]?.unit;
+            if (!prior || prior.id !== unitID || next.id !== unitID)
+                return next;
+            const { validation_cwd: _cwd, ...rest } = next;
+            return { ...rest, validation: prior.validation, ...(prior.validation_cwd ? { validation_cwd: prior.validation_cwd } : {}) };
+        }) }));
+}
 /** Root-owned durable queue. It never executes code, changes acceptance, or accepts a candidate. */
 export class OperatorRuntime {
     profile;
@@ -749,8 +766,8 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false, context) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements, context }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false, context, terminalTaskCalls) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements, context, terminalTaskCalls }));
     }
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root, runID, raw, dispatcher, context) {
@@ -766,26 +783,22 @@ export class OperatorRuntime {
                 unit.directExecution.actor !== actor || unit.directExecution.finishedAt || unit.reviewerCorrection ||
                 plan.units.length !== state.units.length)
                 throw new Error("mission-validation-registration-owner-mismatch");
-            const original = { ...plan, units: plan.units.map((next, i) => {
-                    const prior = state.units[i].unit;
-                    if (prior.validation_cwd)
-                        return { ...next, validation_cwd: prior.validation_cwd };
-                    const { validation_cwd: _cwd, ...rest } = next;
-                    return rest;
-                }) };
-            if (hash(JSON.stringify(original)) !== state.planHash || plan.units.some((next, i) => next.id !== unit.unit.id && JSON.stringify(next.validation_cwd) !== JSON.stringify(state.units[i].unit.validation_cwd))) {
+            if (directValidationRegistrationPlanHash(state, plan, unit.unit.id) !== state.planHash) {
                 throw new Error("mission-validation-registration-contract-mismatch");
             }
-            const cwd = plan.units.find(next => next.id === unit.unit.id).validation_cwd ?? {};
-            const previousCwd = unit.directExecution.validationCwd ?? unit.unit.validation_cwd ?? {};
-            if (JSON.stringify(cwd) !== JSON.stringify(previousCwd)) {
+            const next = plan.units.find(next => next.id === unit.unit.id);
+            const validation = next.validation.map(normalizeCommand), cwd = next.validation_cwd ?? {};
+            const previousValidation = unitValidation(unit), previousCwd = unitValidationCwd(unit) ?? {};
+            if (JSON.stringify(validation) !== JSON.stringify(previousValidation) || JSON.stringify(cwd) !== JSON.stringify(previousCwd)) {
                 // Keep old checks as history, never attach a new recipe to their old successes.
                 const registeredAt = { ...unit.directExecution.validationRegisteredAt }, now = new Date().toISOString();
-                for (const command of unit.unit.validation.map(normalizeCommand)) {
-                    if (resolve(this.projectRoot, cwd[command] ?? ".") !== resolve(this.projectRoot, previousCwd[command] ?? ".")) {
+                for (const command of validation) {
+                    if (previousValidation.filter(item => item === command).length !== validation.filter(item => item === command).length ||
+                        resolve(this.projectRoot, cwd[command] ?? ".") !== resolve(this.projectRoot, previousCwd[command] ?? ".")) {
                         registeredAt[command] = now;
                     }
                 }
+                unit.validationRegistration = { validation, cwd, registeredAt, checks: unit.validationRegistration?.checks ?? [] };
                 unit.directExecution.validationCwd = cwd;
                 unit.directExecution.validationRegisteredAt = registeredAt;
                 await this.save(state);
@@ -837,9 +850,9 @@ export class OperatorRuntime {
         return this.serial(root, async () => {
             const state = await this.required(root);
             const unit = state.units.find(item => /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
-            const execution = unit?.reviewerCorrection ?? unit?.directExecution;
+            const execution = unit?.reviewerCorrection ?? unit?.directExecution ?? unit?.validationRegistration;
             if (!unit || !execution || unit.callID !== check.dispatchCallID || unit.childSessionID !== check.childSessionID ||
-                (unit.reviewerCorrection?.author ?? unit.directExecution?.actor) !== check.childSessionID)
+                (unit.reviewerCorrection?.author ?? unit.directExecution?.actor ?? unit.childSessionID) !== check.childSessionID)
                 throw new Error("mission-review-correction-check-owner-mismatch");
             const checks = execution.checks ??= [];
             if (checks.some(item => item.callID === check.callID))
@@ -906,8 +919,8 @@ export class OperatorRuntime {
                 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) ||
-                JSON.stringify(plan.units[0].validation) !== JSON.stringify(previous.units.flatMap(item => item.unit.validation)) ||
-                JSON.stringify(plan.units[0].validation_cwd ?? {}) !== JSON.stringify(Object.assign({}, ...previous.units.map(item => item.directExecution?.validationCwd ?? item.unit.validation_cwd ?? {}))) ||
+                JSON.stringify(plan.units[0].validation) !== JSON.stringify(previous.units.flatMap(unitValidation)) ||
+                JSON.stringify(plan.units[0].validation_cwd ?? {}) !== JSON.stringify(Object.assign({}, ...previous.units.map(item => unitValidationCwd(item) ?? {}))) ||
                 JSON.stringify(plan.source_refs) !== JSON.stringify(previous.sourceRefs) ||
                 plan.units.some(unit => unit.write.some(path => !this.pathAuthorized(path, mission.reviewerCorrection.writeUnion))))) {
                 throw new Error("mission-review-correction-contract-mismatch");
@@ -933,6 +946,17 @@ export class OperatorRuntime {
         if (mission?.supersededRunID !== undefined && !superseding)
             throw new Error("mission-superseded-run-mismatch");
         const terminalChildren = mission?.terminalChildren ?? [];
+        const unclaimedCalls = previous?.units.flatMap(unit => !unit.directExecution && unit.status === "cancelled" &&
+            unit.childSessionID === null && unit.callID !== null ? [unit.callID] : []) ?? [];
+        // A cancelled admission can precede its child's first prompt. Only the owning
+        // profile's exact native Task proof, not null or cancellation alone, closes it.
+        if (mission && previous?.phase === "cancelled" && unclaimedCalls.length &&
+            (mission?.terminalTaskCalls?.runID !== previous.runID ||
+                new Set(mission.terminalTaskCalls.callIDs).size !== unclaimedCalls.length ||
+                mission.terminalTaskCalls.callIDs.length !== unclaimedCalls.length ||
+                unclaimedCalls.some(call => !mission.terminalTaskCalls.callIDs.includes(call)))) {
+            throw new Error("mission-cancelled-run-task-not-terminal");
+        }
         const retainAcceptance = previous !== undefined && cancelledMissionRetainsAcceptance(previous);
         const predecessorChildren = previous?.units.flatMap(unit => !unit.directExecution && unit.childSessionID !== null
             ? [unit.childSessionID] : []) ?? [];
@@ -944,7 +968,7 @@ export class OperatorRuntime {
             unit.repairValidation !== null || (unit.status === "pending" && (unit.callID !== null || unit.childSessionID !== null ||
             unit.evidence.length > 0 || unit.resultClass !== null)) ||
             (unit.status === "succeeded" && (unit.childSessionID === null || unit.callID === null || unit.evidence.length === 0 || unit.resultClass !== "acceptance")) ||
-            (unit.status === "cancelled" && (unit.childSessionID === null || unit.callID === null))))) {
+            (unit.status === "cancelled" && unit.callID === null)))) {
             throw new Error("mission-superseded-run-has-work: reconcile prior workers and evidence before changing acceptance");
         }
         if (plan.git_lifecycle !== undefined) {
@@ -1184,9 +1208,11 @@ export class OperatorRuntime {
                     await handle.close();
                 }
             }
-            if ((superseding || replanning || previous?.phase === "completed") && previous) {
+            if ((superseding || replanning || previous?.phase === "completed" ||
+                previous?.phase === "cancelled" && unclaimedCalls.length > 0 && mission?.terminalTaskCalls !== undefined) && 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.
+                // Same-request recovery also retains the original unclaimed cancellation, not just its costs.
                 const archive = replanning || previous.phase === "completed" ? this.replanArchivePath(previous)
                     : `${this.file(root)}.${previous.runID}.archive`;
                 try {
@@ -1357,6 +1383,28 @@ export class OperatorRuntime {
             : args;
         return unit !== undefined && this.matchesWorkerTask(state, unit, normalized);
     }
+    /** Historical comparison only: cancellation revoked the admission generation. */
+    matchesCancelledWorkerTask(state, unitID, args) {
+        const unit = state.units.find(item => item.unit.id === unitID);
+        if (state.phase !== "cancelled" || !unit || unit.status !== "cancelled" || unit.childSessionID !== null ||
+            !record(args) || typeof args.prompt !== "string")
+            return false;
+        if (args.prompt === unit.task.prompt)
+            return this.matchesRecordedWorkerTask(state, unitID, args);
+        if (!args.prompt.startsWith(`${OPERATOR_TASK_REFERENCE} `))
+            return false;
+        let reference;
+        try {
+            reference = JSON.parse(args.prompt.slice(OPERATOR_TASK_REFERENCE.length + 1));
+        }
+        catch {
+            return false;
+        }
+        if (!record(reference) || !Number.isSafeInteger(reference.g) || reference.g < 1 ||
+            reference.g >= state.generation)
+            return false;
+        return this.matchesRecordedWorkerTask({ ...state, generation: reference.g }, unitID, args);
+    }
     admitOperator(root, callID, args) {
         return this.serial(root, () => this.admitOperatorOnce(root, callID, args));
     }
@@ -1467,14 +1515,15 @@ export class OperatorRuntime {
                 throw new Error("mission-direct-handoff-unavailable");
             }
             await this.verifyControls(unit);
-            const segment = { ...structuredClone(unit.directExecution), callID: unit.callID, handedOffAt: new Date().toISOString() };
+            const segment = { ...structuredClone(unit.directExecution), validation: unitValidation(unit),
+                callID: unit.callID, handedOffAt: new Date().toISOString() };
             // Keep the original controls immutable. Publish continuation context and the new
             // Task reference together in the atomic run save, so a crash has no half-updated pins.
             const continuation = { actor, unit_id: unit.unit.id, at: segment.handedOffAt,
-                instruction: "Continue existing changes and remaining action. The authoritative handoff retains the exact original requirements. Reuse current source-bound checks; inspect missing facts only. Handoff itself is not validation.",
+                instruction: "Continue existing changes and remaining action. The authoritative handoff retains the exact original requirements. This continuation's validation/validation_cwd is the effective registration, superseding only the frozen check recipe. Reuse current source-bound checks; inspect missing facts only. Handoff itself is not validation.",
                 continuity: context.continuity,
                 checks: segment.checks.map(({ callID, command, directory, exitCode, startedAt, endedAt }) => ({ callID, command, directory, exitCode, startedAt, endedAt })),
-                validation_cwd: segment.validationCwd ?? unit.unit.validation_cwd, details_ref: this.statePath(root) };
+                validation: segment.validation, validation_cwd: unitValidationCwd(unit), details_ref: this.statePath(root) };
             unit.task = { ...unit.task, prompt: `${unit.task.prompt.replace(/\ndirect_handoff: .+$/mu, "")}\ndirect_handoff: ${JSON.stringify(continuation)}` };
             (unit.directHandoffs ??= []).push(segment);
             delete unit.directExecution;
@@ -1610,7 +1659,7 @@ export class OperatorRuntime {
     }
     async captureContractRepair(state, unit, error, command) {
         const normalized = normalizeCommand(command);
-        const commandIndex = unit.unit.validation.map(normalizeCommand).indexOf(normalized);
+        const commandIndex = unitValidation(unit).map(normalizeCommand).indexOf(normalized);
         if (commandIndex < 0)
             throw new Error("operator-contract-repair-validation-command-missing");
         const paths = [...new Set(error.diagnostics.flatMap(item => item.repair_paths ?? []))].sort();
@@ -1630,7 +1679,7 @@ export class OperatorRuntime {
         return { code: "operator-git-change-outside-write-union", unit_id: unit.unit.id,
             diagnostics: structuredClone(error.diagnostics), diagnostics_truncated: error.diagnostics_truncated,
             repair_generation: 0, mode, repair_fingerprint: repairFingerprint, files,
-            remaining_validation: unit.unit.validation.slice(commandIndex).map(normalizeCommand) };
+            remaining_validation: unitValidation(unit).slice(commandIndex).map(normalizeCommand) };
     }
     recordContractRepair(root, actor, error, command) {
         return this.serial(root, async () => {
@@ -2368,7 +2417,7 @@ export class OperatorRuntime {
                 id: unit.unit.id, status: unit.status, child_session_id: unit.childSessionID, result_class: unit.resultClass,
                 task_ref: unit.status === "pending" ? (unit.repairValidation === null ? this.workerTask(state, unit).prompt : this.repairWorkerTask(state, unit).prompt) : null,
                 handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
-                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
+                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unitValidation(unit),
                 acceptance_indices: unit.unit.acceptance_indices,
                 normal_remediation_used: unit.normalRemediationUsed ?? false,
                 ...(unit.terminalRescue ? { terminal_rescue: { attempt_id: unit.terminalRescue.attempt_id,
@@ -2398,7 +2447,7 @@ export class OperatorRuntime {
             unit_id: unit.unit.id, task_id: /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1],
             project_root: this.projectRoot, handoff_path: this.controlReference(unit.handoffPath), operation_manifest: this.controlReference(unit.manifestPath),
             objective: unit.unit.objective, read: unit.unit.read, write: unit.unit.write,
-            validation: unit.unit.validation, acceptance: state.acceptance,
+            validation: unitValidation(unit), acceptance: state.acceptance,
             ...(unit.repairValidation === null ? {} : { validation_only: true }),
         })}\nThis is the durable assignment for this same Worker, including after compaction or reload. ` +
             "A missing path in a summary does not mean the handoff is missing. Read the retained handoff/manifest using these project-relative paths without prepending project_root, and inspect the actual diff and outputs before claiming no edits or replaying work. " +

package/dist/plugin/index.js

@@ -41,7 +41,7 @@ import { CancellableChildLifecycle, DEFAULT_CHILD_DEADLINE_MS } from "../core/ch
 import { FailureSwarmRuntime } from "../core/failure-swarm-runtime.js";
 import { EvidenceCapsuleStore } from "../core/evidence-capsule.js";
 import { RunFlightLedger, diagnosisContractHash } from "../core/run-flight-ledger.js";
-import { GOAL_BOUND_METADATA_KEY, goalFingerprint, selectGoalDelivery, validGoalEvidence } from "../core/goal-bound.js";
+import { GOAL_BOUND_METADATA_KEY, goalFingerprint, goalValidationCommand, selectGoalDelivery, validGoalEvidence } from "../core/goal-bound.js";
 import { LUNA_FABRIC_MAX_ACTIVE } from "../core/luna-fabric-scheduler.js";
 import { terminalRescueModel } from "./terminal-rescue-binding.js";
 import { TerminalRescueRuntime } from "../core/terminal-rescue-runtime.js";
@@ -1381,7 +1381,8 @@ export const SortieDogsPlugin = async (input, options) => {
         const rawCommand = args !== undefined && typeof args.command === "string" ? normalizeCommand(args.command) : undefined;
         if (rawCommand === undefined || rawCommand.length === 0)
             return;
-        const correcting = !!direct || await input.runtimeBridge?.ownsReviewerCorrection?.(toolInput.sessionID) === true;
+        const correcting = !!direct || await input.runtimeBridge?.ownsReviewerCorrection?.(toolInput.sessionID) === true ||
+            await input.runtimeBridge?.ownsValidationRegistration?.(toolInput.sessionID) === true;
         const directory = dockerRequest?.cwd ?? resolve(input.directory, typeof args?.workdir === "string" ? args.workdir : ".");
         // A check is proof only in its registered cwd. Snapshot the same admitted source
         // recipe at actual native start; never retrofit it to older external-cwd history.
@@ -1413,7 +1414,7 @@ export const SortieDogsPlugin = async (input, options) => {
         let reusedEvidence;
         const unitID = authorization.taskID;
         const repairResume = operatorContractRepairResumes.get(root);
-        const criteria = goal.acceptance_contract?.criteria.filter((criterion) => (correction ? criterion.validation_command !== undefined && correction.commands.includes(criterion.validation_command) : criterion.validation_command === rawCommand) &&
+        const criteria = goal.acceptance_contract?.criteria.filter((criterion) => (correction ? goalValidationCommand(goal, criterion) !== undefined && correction.commands.includes(goalValidationCommand(goal, criterion)) : goalValidationCommand(goal, criterion) === rawCommand) &&
             criterion.expected_outcome === "pass") ?? [];
         const denyValidation = (reason) => {
             goalValidationDefects.add(toolInput.sessionID);
@@ -1438,7 +1439,7 @@ export const SortieDogsPlugin = async (input, options) => {
         if (goal.goal_id !== null && criteria.length > 0) {
             const requestedFull = criteria.some((criterion) => criterion.proof_scope === "requested-full");
             const coordinatorOwned = requestedFull && unitID !== undefined &&
-                await input.runtimeBridge?.ownsCanonicalValidation?.(root, unitID, toolInput.sessionID, correction ? criteria[0].validation_command : rawCommand) === true;
+                await input.runtimeBridge?.ownsCanonicalValidation?.(root, unitID, toolInput.sessionID, correction ? goalValidationCommand(goal, criteria[0]) : rawCommand) === true;
             if (requestedFull && !coordinatorOwned)
                 throw denyValidation("owner-mismatch: coordinator-routing-unavailable");
             const profile = loaded?.validationProfile ?? DEFAULT_PLUGIN_OPTIONS.validationProfile;
@@ -2485,7 +2486,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 Date.parse(execution.startedAt) >= Date.parse(check.startedAt));
             return laterFailure ? [] : observedHostGoalEvidence({ ...check, owner: "coordinator", outcome: "pass",
                 immutableRef: goalFingerprint({ direct_check: check }),
-                correction: { taskID: reservation.unitID, dispatchCallID: check.dispatchCallID, commands: check.command } }, state, reservation.unitID);
+                correction: { taskID: reservation.unitID, dispatchCallID: check.dispatchCallID,
+                    commands: check.matchedOccurrences.map(item => check.command[item.member]) } }, state, reservation.unitID);
         });
         const hostEvidence = [...new Map((directEvidence ?? [...observedEvidence, ...inherited]).map(entry => [entry.evidence_id, entry])).values()];
         // A worker may return after a user scope epoch changed. Settle its spend/reservation, but only
@@ -8426,6 +8428,21 @@ export const SortieDogsPlugin = async (input, options) => {
             sessionTaskIDs.set(child, taskID);
             activateSession(child);
         },
+        registerDirectValidation: async (root, actor, criterionID, command, registeredAt) => {
+            const direct = await input.runtimeBridge?.directMissionExecution?.(actor);
+            if (!direct || direct.root !== root || !await input.runtimeBridge?.ownsCanonicalValidation?.(root, direct.taskID, actor, command)) {
+                throw new Error("mission-validation-registration-owner-mismatch");
+            }
+            const ledger = await goalLedger(root), state = (await ledger.readGoal()).state;
+            const reservation = state.outstanding_reservations.find(item => item.unit_id === direct.taskID && item.session_id === root);
+            if (!reservation || state.phase !== "active" || !state.goal_id)
+                throw new Error("mission-validation-registration-reservation-missing");
+            const prior = state.validation_registrations?.[criterionID];
+            if (prior?.unit_id === direct.taskID && prior.command === command && prior.registered_at === registeredAt)
+                return;
+            await ledger.appendGoal({ kind: "goal.validation-registered", at: new Date().toISOString(), goal_id: state.goal_id,
+                reservation_id: reservation.reservation_id, unit_id: direct.taskID, criterion_id: criterionID, command, registered_at: registeredAt });
+        },
         activateDirectUnit: (root, actor, prompt, handoffPath) => serializeChatTransition(actor, async () => {
             const direct = await input.runtimeBridge?.directMissionExecution?.(actor);
             if (!direct || direct.root !== root)

package/dist/plugin/mission-review.d.ts

@@ -1,7 +1,7 @@
-import type { OperatorState } from "../core/operator-runtime.js";
+import { type OperatorState } from "../core/operator-runtime.js";
 import { type MissionEvidenceExcerpt, type MissionReviewScope, type OperatorMission } from "../core/operator-mission.js";
 import { type RuntimeProfile } from "../core/runtime-profile.js";
-import type { ReviewerCorrectionCheck } from "./runtime-bridge.js";
+import type { DirectHandoffValidationCheck, ReviewerCorrectionCheck } from "./runtime-bridge.js";
 export declare const validationDirectoryMatches: (commands: readonly string[], actual: string | undefined, directory?: string, directories?: Readonly<Record<string, string>>) => boolean;
 /** Reviewer-facing evidence preserves execution/coverage; the host retains the full snapshot recipe. */
 export declare function missionReviewValidation(run: OperatorState, statePath: string): {
@@ -125,7 +125,7 @@ export declare function reviewerCorrectionValidationFresh(validation: readonly s
     nextOccurrence?: number;
 }>;
 /** Preserve a current ordered prefix while the next author executes the remaining recipe. */
-export declare function directHandoffValidationChecks(...args: Parameters<typeof reviewerCorrectionValidationFresh>): Promise<readonly ReviewerCorrectionCheck[]>;
+export declare function directHandoffValidationChecks(...args: Parameters<typeof reviewerCorrectionValidationFresh>): Promise<readonly DirectHandoffValidationCheck[]>;
 /** Summary-only native reader: unavailable API/error is not a successfully observed empty history. */
 export declare function observedMissionValidationSummary(validation: readonly string[], childSessionID: string, read?: () => Promise<unknown>, notBefore?: number, directory?: string, directories?: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;
 export declare function missionReviewBaseline(directory: string): Promise<string | undefined>;

package/dist/plugin/mission-review.js

@@ -5,6 +5,7 @@ import { lstat, readlink, readdir } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { createInterface } from "node:readline";
+import { unitValidation, unitValidationCwd } from "../core/operator-runtime.js";
 import { TOOL_ENVIRONMENT } from "../runtime-mission-assets.js";
 import { MISSION_REVIEW_REFERENCE, missionReviewScope } from "../core/operator-mission.js";
 import { canonicalAgent } from "../core/runtime-profile.js";
@@ -39,9 +40,9 @@ export const validationDirectoryMatches = (commands, actual, directory, director
 export function missionReviewValidation(run, statePath) {
     return run.units.map(unit => ({
         unit_id: unit.unit.id,
-        command: unit.unit.validation,
-        ...(unit.directExecution?.validationCwd ?? unit.unit.validation_cwd ? {
-            validation_cwd: unit.directExecution?.validationCwd ?? unit.unit.validation_cwd,
+        command: unitValidation(unit),
+        ...(unitValidationCwd(unit) ? {
+            validation_cwd: unitValidationCwd(unit),
         } : {}),
         evidence: unit.evidence.map(({ protected_binding, ...evidence }) => ({
             ...evidence,
@@ -381,7 +382,11 @@ export async function directHandoffValidationChecks(...args) {
     for (let count = validation.length; count > 0; count--) {
         const result = await reviewerCorrectionValidationFresh(validation.slice(0, count), child, history, started, checks, root, directories, registeredAt);
         if (result.ready)
-            return checks.filter(check => result.matched?.some(item => item.callID === check.callID));
+            return checks.flatMap(check => {
+                const matchedOccurrences = result.matched?.filter(item => item.callID === check.callID)
+                    .map(({ member, occurrence }) => ({ member, occurrence })) ?? [];
+                return matchedOccurrences.length ? [{ ...check, matchedOccurrences }] : [];
+            });
     }
     return [];
 }

package/dist/plugin/profiled.js

@@ -1,6 +1,6 @@
 import { V010_RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { MISSION_BEHAVIOR_REVIEW, MISSION_GIT_SCOPE, REVIEWER_VALIDATION_WORKFLOW } from "../runtime-mission-assets.js";
-import { cancelledMissionRetainsAcceptance, operatorGitPathAuthorized, OperatorContractError, OperatorRuntime } from "../core/operator-runtime.js";
+import { cancelledMissionRetainsAcceptance, directValidationRegistrationPlanHash, unitValidation, unitValidationCwd, operatorGitPathAuthorized, OperatorContractError, OperatorRuntime } from "../core/operator-runtime.js";
 import { DEFAULT_OPERATOR_PROPOSAL_BUDGET, OPERATOR_APPROVAL_CONTRACT, OPERATOR_PROPOSAL_BUDGET_CAPS, OPERATOR_PROPOSAL_REVISION_CONTRACT, OperatorProposalBudgetError, OperatorProposalRuntime } from "../core/operator-proposal.js";
 import { CANONICAL_AGENT_ROLES, canonicalAgent, profileAgent, profileTool, V010_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 import { SortieDogsPlugin as canonicalPlugin, realAttachmentParts } from "./index.js";
@@ -256,7 +256,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             const method = typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages";
             return observedMissionValidationSummary(validation, child, typeof nativeSession?.[method] === "function"
                 ? () => session(method, { path: { id: child }, query: { directory: input.directory,
-                        ...(notBefore === undefined ? {} : { notBefore: new Date(notBefore).toISOString() }) } }) : undefined, notBefore, notBefore === undefined ? undefined : input.directory, direct?.unit.directExecution?.validationCwd ?? direct?.unit.unit.validation_cwd);
+                        ...(notBefore === undefined ? {} : { notBefore: new Date(notBefore).toISOString() }) } }) : undefined, notBefore, notBefore === undefined ? undefined : input.directory, direct ? unitValidationCwd(direct.unit) : undefined);
         }
         async function reviewMessages(id, notBefore, requireAvailable = false) {
             const method = typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages";
@@ -498,6 +498,34 @@ export function createProfiledPlugin(profile, assetVersion) {
                 return undefined;
             return unit ? { root, mission, run, unit } : undefined;
         }
+        async function registeredValidation(id) {
+            const root = await rootFor(id);
+            if (!root)
+                return undefined;
+            const mission = await missions.read(root), run = await operators.read(root);
+            if (!mission || !run || mission.runID !== run.runID || run.phase !== "running" ||
+                ["completed", "cancelled"].includes(mission.phase))
+                return undefined;
+            const unit = run.units.find(item => item.status === "running" && item.childSessionID === id && item.validationRegistration);
+            return unit ? { root, mission, run, unit } : undefined;
+        }
+        async function remainingRegisteredValidation(root, unit) {
+            const validation = unitValidation(unit);
+            if (unit.directExecution || !unit.validationRegistration || !unit.callID)
+                return validation;
+            const taskID = /^task_id: (.+)$/mu.exec(unit.task.prompt)?.[1];
+            const inherited = taskID ? await runtimeBridge.missionHandoffChecks(root, taskID, unit.callID) : [];
+            let prefix = inherited.reduce((count, check) => count + check.matchedOccurrences.length, 0);
+            // A new author's actual retry supersedes that inherited occurrence, including
+            // a later failure. Never let an earlier handed-off PASS hide this native result.
+            for (const check of unit.validationRegistration.checks)
+                for (const command of check.command) {
+                    const occurrence = validation.indexOf(command);
+                    if (occurrence >= 0)
+                        prefix = Math.min(prefix, occurrence);
+                }
+            return validation.slice(prefix);
+        }
         /**
          * Resolve the owning root of a proposal investigation child for prompt assembly only.
          *
@@ -644,14 +672,14 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const unit = state.units.find(candidate => /^task_id: (.+)$/m.exec(candidate.task.prompt)?.[1] === taskID);
                 const active = unit?.status === "running" || (unit?.status === "failed" && unit.repairValidation !== null);
                 return active && unit.childSessionID === child &&
-                    unit.unit.validation.some(candidate => normalizeCommand(candidate) === command);
+                    unitValidation(unit).some(candidate => normalizeCommand(candidate) === command);
             },
             beforeValidationSnapshot: (root, child, command) => operators.beforePostCommitValidation(root, child, command),
             requiresValidationExecution: async (root, taskID, child, commands) => {
                 const run = await operators.read(root);
                 const unit = run?.units.find(item => item.status === "running" && item.childSessionID === child &&
                     /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
-                return !!unit && commands.some(command => unit.unit.validation.filter(item => normalizeCommand(item) === command).length > 1);
+                return !!unit && commands.some(command => unitValidation(unit).filter(item => normalizeCommand(item) === command).length > 1);
             },
             ownsMissionDispatch: async (root, callID, taskID) => {
                 const mission = await missions.read(root), state = await operators.read(root);
@@ -661,6 +689,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1] === taskID);
             },
             ownsReviewerCorrection: async (child) => !!await reviewerCorrection(child),
+            ownsValidationRegistration: async (child) => !!await registeredValidation(child),
             directMissionExecution: async (actor) => {
                 const direct = await directExecution(actor);
                 const taskID = direct && /^task_id: (.+)$/mu.exec(direct.unit.task.prompt)?.[1];
@@ -683,21 +712,24 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return [];
                 try {
                     const history = await reviewMessages(prior.actor, prior.startedAt, true);
-                    return await directHandoffValidationChecks(unit.unit.validation, prior.actor, history, Date.parse(prior.startedAt), prior.checks, input.directory, prior.validationCwd ?? unit.unit.validation_cwd, prior.validationRegisteredAt);
+                    return await directHandoffValidationChecks(unitValidation(unit), prior.actor, history, Date.parse(prior.startedAt), prior.checks, input.directory, prior.validationCwd ?? unit.unit.validation_cwd, prior.validationRegisteredAt);
                 }
                 catch {
                     return [];
                 }
             },
             reviewerCorrectionValidationMembers: async (child, command, directory) => {
-                const correction = await reviewerCorrection(child) ?? await directExecution(child);
+                const correction = await reviewerCorrection(child) ?? await directExecution(child) ?? await registeredValidation(child);
                 if (!correction)
                     return undefined;
                 const unit = correction.unit;
-                const directories = unit.directExecution?.validationCwd ?? unit.unit.validation_cwd;
+                const directories = unitValidationCwd(unit);
                 const admittedAt = unit.reviewerCorrection?.admittedAt ?? unit.directExecution?.startedAt ?? correction.run.createdAt;
-                const progress = reviewerCorrectionValidation(unit.unit.validation, child, await reviewMessages(child, admittedAt), Date.parse(admittedAt), unit.reviewerCorrection?.checks ?? unit.directExecution?.checks ?? [], input.directory, directories, unit.reviewerCorrection?.validationRegisteredAt ?? unit.directExecution?.validationRegisteredAt);
-                const members = canonicalObservedValidationMembers(command, unit.unit.validation, progress.nextOccurrence ?? 0);
+                const validation = await remainingRegisteredValidation(correction.root, unit);
+                const progress = reviewerCorrectionValidation(validation, child, await reviewMessages(child, admittedAt), Date.parse(admittedAt), unit.reviewerCorrection?.checks ?? unit.directExecution?.checks ?? unit.validationRegistration?.checks ?? [], input.directory, directories, unit.reviewerCorrection?.validationRegisteredAt ?? unit.directExecution?.validationRegisteredAt ?? unit.validationRegistration?.registeredAt);
+                // Progress is relative to the remaining suffix; native matching uses the
+                // full declaration so a retry of an inherited occurrence is captured too.
+                const members = canonicalObservedValidationMembers(command, unitValidation(unit), unitValidation(unit).length - validation.length + (progress.nextOccurrence ?? 0));
                 return members && validationDirectoryMatches(members, directory, input.directory, directories) ? members : undefined;
             },
             recordReviewerCorrectionCheck: (root, taskID, check) => operators.recordReviewerCorrectionCheck(root, taskID, check),
@@ -706,18 +738,21 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // Recovery also compares failed units after their native Task has ended.
                 const unit = run?.units.find(item => item.childSessionID === child &&
                     /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
-                return !unit || validationDirectoryMatches(commands, directory, input.directory, unit.directExecution?.validationCwd ?? unit.unit.validation_cwd);
+                return !unit || validationDirectoryMatches(commands, directory, input.directory, unitValidationCwd(unit));
             },
             reviewerCorrectionValidation: async (root, callID, child, startedAt) => {
                 const run = await operators.read(root);
                 const unit = run?.units.find(item => item.callID === callID && item.childSessionID === child &&
-                    (item.reviewerCorrection?.author === child || item.directExecution?.actor === child));
+                    (item.reviewerCorrection?.author === child || item.directExecution?.actor === child || item.validationRegistration));
                 if (!unit)
                     return undefined;
                 // Compaction removes earlier tools from session.context, not from native history.
                 // Reuse the admission-window reader; saved checks still require their live input binding.
                 try {
-                    return await reviewerCorrectionValidationFresh(unit.unit.validation, child, await reviewMessages(child, new Date(startedAt).toISOString()), startedAt, unit.reviewerCorrection?.checks ?? unit.directExecution?.checks ?? [], input.directory, unit.directExecution?.validationCwd ?? unit.unit.validation_cwd, unit.reviewerCorrection?.validationRegisteredAt ?? unit.directExecution?.validationRegisteredAt);
+                    const validation = await remainingRegisteredValidation(root, unit);
+                    if (!validation.length && unitValidation(unit).length)
+                        return { ready: true, matched: [] };
+                    return await reviewerCorrectionValidationFresh(validation, child, await reviewMessages(child, new Date(startedAt).toISOString()), startedAt, unit.reviewerCorrection?.checks ?? unit.directExecution?.checks ?? unit.validationRegistration?.checks ?? [], input.directory, unitValidationCwd(unit), unit.reviewerCorrection?.validationRegisteredAt ?? unit.directExecution?.validationRegisteredAt ?? unit.validationRegistration?.registeredAt);
                 }
                 catch {
                     return { ready: false, reason: "mission-review-correction-validation-history-unavailable" };
@@ -1216,6 +1251,9 @@ export function createProfiledPlugin(profile, assetVersion) {
             return packet;
         }
         function missionDispatchPacket(mission, run) {
+            const strategyRecovery = " If a method stalled or proposed avoidable extra work, Operator: compare the original goal, actual result and concrete unmet work before choosing to continue, change or stop that method. " +
+                `For a concrete adjustment, use ${profile.toolPrefix}plan_units with proposed units, reason and handoff_context, then dispatch its returned same-Coordinator continuation. ` +
+                "Preserve required checks through lawful registration/replanning and reuse current evidence. Otherwise continue normally; no extra approval or logging-only step.";
             const packet = { ...missionPacket(mission, run), project_root: input.directory,
                 coordinator_dispatch: mission.dispatchOpen ? "active" : ["completed", "cancelled"].includes(mission.phase) ? "terminal" : "resumable" };
             if (mission.phase === "submitted" && mission.submission?.status === "blocked" &&
@@ -1249,7 +1287,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (mission.runID === run?.runID && run?.units.some(unit => unit.status === "running")) {
                 if (mission.coordinator && !mission.dispatchOpen && !["completed", "cancelled"].includes(mission.phase))
                     return { ...packet, task: missions.task(mission),
-                        next_action: "Resume this existing Coordinator Task with its task_id to continue the retained unit. Do not dispatch a replacement or wait for background work that has already ended." };
+                        next_action: "Resume this existing Coordinator Task with its task_id to continue the retained unit. Do not dispatch a replacement or wait for background work that has already ended." + strategyRecovery };
                 return { ...packet, next_action: "The current unit is active. Continue its owning session; do not dispatch a replacement Worker or Coordinator. Native background completion will return to the parent." };
             }
             if (mission.coordinator === null && mission.runID === run?.runID && !mission.dispatchOpen &&
@@ -1295,7 +1333,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     next_action: (run?.units.some(unit => unit.dispatchDenial) ? `${packet.next_action}\n` : "") +
                         (mission.coordinator === null
                             ? "Fast-lane needs correction or coordination: dispatch this exact Coordinator Task with the existing Worker changes, checks and concrete remaining work. Keep the same mission, requirements and cumulative budget; do not replace an active Worker."
-                            : "The previous Coordinator Task is finished. Dispatch this exact Task to continue the same mission and Coordinator session; keep the original requirements and cumulative budget.") };
+                            : "The previous Coordinator Task is finished. Dispatch this exact Task to continue the same mission and Coordinator session; keep the original requirements and cumulative budget." + strategyRecovery) };
             }
             return packet;
         }
@@ -1524,6 +1562,58 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await operators.recordStoppedChild(root, run.runID, child);
             }
         }
+        async function cancelledUnclaimedTaskCalls(root, run) {
+            const units = run.units.filter(unit => !unit.directExecution && unit.status === "cancelled" &&
+                unit.childSessionID === null && unit.callID !== null);
+            if (!units.length)
+                return undefined;
+            const owner = run.operatorSessionID ?? root;
+            const deny = () => new Error("mission-cancelled-run-task-not-terminal");
+            // The bounded chat context may omit the old Task. Use the existing native
+            // history reader, and never substitute a model's stop report for a tool terminal.
+            const history = await reviewMessages(owner, undefined, true);
+            for (const unit of units) {
+                const parts = history.flatMap(message => record(message.info) && message.info.role === "assistant" &&
+                    message.info.sessionID === owner && Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) && part.type === "tool" && part.tool === "task" && part.callID === unit.callID);
+                const part = parts.length === 1 && record(parts[0]) ? parts[0] : undefined;
+                const state = part && record(part.state) ? part.state : undefined;
+                if (!part || part.sessionID !== undefined && part.sessionID !== owner || !state ||
+                    !["completed", "error"].includes(String(state.status)) ||
+                    record(state.metadata) && ["running", "pending", "unknown"].includes(String(state.metadata.status)) ||
+                    !record(state.time) || typeof state.time.end !== "number" || !Number.isFinite(state.time.end) ||
+                    !operators.matchesCancelledWorkerTask(run, unit.unit.id, state.input) || taskChildSessionID(state) !== undefined)
+                    throw deny();
+            }
+            // A parent Task terminal does not prove that an unclaimed child never started.
+            // Reuse the owning service's active snapshot and child lineage before allowing
+            // this formerly unrepresentable cancellation into prepareMission.
+            const active = payload(await session("active", {}));
+            if (!record(active) || !Object.values(active).every(value => record(value) &&
+                ["running", "retry"].includes(String(value.type))) || owner !== root && Object.hasOwn(active, owner))
+                throw deny();
+            const children = payload(await session("children", { path: { id: owner }, query: { directory: input.directory } }));
+            if (!Array.isArray(children) || children.some(child => !record(child) || typeof child.id !== "string") ||
+                new Set(children.map(child => child.id)).size !== children.length)
+                throw deny();
+            for (const child of children) {
+                const info = payload(await session("get", { path: { id: child.id }, query: { directory: input.directory } }));
+                if (!record(info) || info.id !== child.id || info.parentID !== owner ||
+                    typeof info.agent !== "string" || !info.agent.trim())
+                    throw deny();
+                const role = canonicalAgent(profile, info.agent);
+                // Root Fast-lane Tasks must not claim unrelated profile or native agents.
+                if (owner === root && role !== "dog-worker" && role !== "dog-luna-worker")
+                    continue;
+                if (!role)
+                    throw deny();
+                const descendants = payload(await session("children", { path: { id: child.id }, query: { directory: input.directory } }));
+                if (Object.hasOwn(active, child.id) || !Array.isArray(descendants) || descendants.length ||
+                    !["succeeded", "failed", "interrupted"].includes(String(info.outcome)) &&
+                        !(info.outcome === undefined && run.stoppedChildren?.includes(child.id)))
+                    throw deny();
+            }
+            return { runID: run.runID, callIDs: units.map(unit => unit.callID) };
+        }
         async function stop(root, reason, retireRoot = true) {
             const directActor = (await operators.read(root))?.units.find(unit => unit.status === "running" && unit.directExecution)?.directExecution?.actor;
             // Stopping owned execution does not write its artifacts. Its existing reservation
@@ -1920,7 +2010,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const gapSummary = reviewGaps?.replace(/^EVIDENCE_GAPS\s*/u, "").replace(/\s+/gu, " ").slice(0, 500);
                     const text = withMissionOperationOutcome(`✅ **DONE** \`${state.runID}\` — declared checks passed; Operator accepted the result.`, mission) + `\n\n` +
                         `**${t("変更点", "Changes")}:** ${state.units.map(unit => unit.unit.title).join("; ")}\n\n` +
-                        `**${t("確認結果", "Validation")}:** ${t("宣言検証合格", "Declared checks passed")} — ${[...new Set(state.units.flatMap(unit => unit.unit.validation))].join("; ")}` +
+                        `**${t("確認結果", "Validation")}:** ${t("宣言検証合格", "Declared checks passed")} — ${[...new Set(state.units.flatMap(unitValidation))].join("; ")}` +
                         (mission?.review ? `\n${t("レビュー", "Review")}: ${mission.review.verdict === "self-rechecked" ? t("修正著者の自己再確認（独立PASSではない）", "Author self-rechecked (not independent PASS)") : mission.review.verdict === "evidence-gaps" ? t("証拠不足を残して受入れ（レビューPASSではない）", "Accepted with evidence gaps (not Review PASS)") : mission.review.verdict}.` : "") +
                         (mission?.deliveryObservation?.head ? `\nCommit: ${mission.deliveryObservation.head} (${mission.deliveryObservation.branch ?? "detached"}; clean=${mission.deliveryObservation.clean})` : "") +
                         (reviewGaps ? `\n\n**${t("レビュー補足", "Review note")}:** ${gapSummary}\n\n**${t("次", "Next")}:** ${t("なし（補足だけを理由に再レビュー不要）", "None (no repeat review solely for the advisory)")}`
@@ -2008,8 +2098,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                             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,
+                                    checks: unit.reviewerCorrection?.checks ?? direct.checks, validation: unitValidation(unit),
+                                    directories: unitValidationCwd(unit),
                                     registeredAt: unit.reviewerCorrection?.validationRegisteredAt ?? direct.validationRegisteredAt } }));
                             recoveredDirect.add(unit.unit.id);
                             continue;
@@ -2284,9 +2374,18 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, repairReview = `${profile.toolPrefix}repair_review`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`, skipMissionConsultation = `${profile.toolPrefix}skip_mission_consultation`, extendMissionBudget = `${profile.toolPrefix}extend_mission_budget`;
         const startDirectUnit = `${profile.toolPrefix}start_direct_unit`, finishDirectUnit = `${profile.toolPrefix}finish_direct_unit`;
+        async function syncDirectValidation(direct) {
+            if (!direct.unit.validationRegistration)
+                return;
+            const last = unitValidation(direct.unit).at(-1);
+            await control.registerDirectValidation(direct.root, direct.unit.directExecution.actor, direct.unit.unit.id, last, direct.unit.directExecution.validationRegisteredAt?.[last] ?? direct.unit.directExecution.startedAt);
+        }
         async function activateDirect(actor) {
             const direct = await directExecution(actor);
             if (direct) {
+                // Recover a crash between durable registration and its goal-ledger projection
+                // before admitting another native check or selecting finish evidence.
+                await syncDirectValidation(direct);
                 await control.activateDirectUnit(direct.root, actor, direct.unit.task.prompt, direct.unit.handoffPath);
             }
             return direct;
@@ -2308,7 +2407,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-direct-binding-unavailable: retain the admitted unit and restore its Mission binding");
             await activateDirect(actor);
             return JSON.stringify({ status: "direct-unit-running", run_id: direct.run.runID, unit_id: direct.unit.unit.id,
-                executor_session_id: actor, validation: direct.unit.unit.validation,
+                executor_session_id: actor, validation: unitValidation(direct.unit),
                 next_action: `Implement/correct and run the declared checks here, in this same session. Call ${finishDirectUnit} after the requested delivery boundary. No Worker or handoff read is needed. Retain the original requirements; independent Review and Operator acceptance still follow.` });
         }
         async function assertMissionRunBound(root) {
@@ -2317,10 +2416,45 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-run-registration-incomplete: retry plan_units with the same plan to finish goal registration and Mission binding; no unit admitted");
             await operators.verifyContinuityControls(run);
         }
+        async function assertDirectPlanningQuiescent(actor, planningCallID) {
+            await control.assertDirectUnitQuiescent(actor);
+            // Cold hook state is not proof. Only the exact current planner may be pending;
+            // a completed background launch or another Task remains an active/unproven writer.
+            const history = payload(await session("messages", { path: { id: actor }, query: { directory: input.directory } }));
+            if (!Array.isArray(history))
+                throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
+            const calls = new Map();
+            for (const message of history) {
+                if (!record(message) || !record(message.info) || message.info.sessionID !== actor || !Array.isArray(message.parts)) {
+                    throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
+                }
+                for (const part of message.parts) {
+                    if (!record(part) || typeof part.type !== "string")
+                        throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
+                    if (part.type !== "tool")
+                        continue;
+                    if (part.callID === planningCallID && planningCallID && part.tool === planUnits)
+                        continue;
+                    if (typeof part.callID !== "string")
+                        throw new Error("mission-replan-terminal-unreconciled:tool_identity_unavailable");
+                    const prior = calls.get(part.callID);
+                    if (prior && prior.tool !== part.tool)
+                        throw new Error("mission-replan-terminal-unreconciled:tool_identity_conflict");
+                    calls.set(part.callID, part);
+                }
+            }
+            for (const part of calls.values()) {
+                if (!record(part.state) || !["completed", "error"].includes(String(part.state.status)) ||
+                    record(part.state.metadata) && ["running", "pending", "unknown"].includes(String(part.state.metadata.status))) {
+                    throw new Error("mission-replan-terminal-unreconciled:tool_dispatch_active_or_unproven");
+                }
+            }
+        }
         async function handoffDirect(root, actor, callID, notes) {
             const direct = await directExecution(actor);
             if (direct) {
                 await control.assertDirectUnitQuiescent(actor);
+                await syncDirectValidation(direct);
                 const history = await reviewMessages(actor, direct.unit.directExecution.startedAt, true);
                 const calls = new Map();
                 for (const message of history)
@@ -2390,7 +2524,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     if (direct.unit.reviewerCorrection)
                         return JSON.stringify({ status: "correction-validated",
-                            execution: "same-native-task", validation: direct.unit.unit.validation,
+                            execution: "same-native-task", validation: unitValidation(direct.unit),
                             next_action: 'Compare the original requirements, retained findings and affected public behavior in this same context, then finish THIS native Task with SELF_RECHECKED and self_recheck: {"candidate":"current-validated","unresolved_findings":[],"residual_major":null}. No handoff reread, second Task or Operator round trip. This is author self-recheck; only the actual successful native terminal can bind it, never this tool result.' });
                     const run = await operators.required(root);
                     // Full protected path arrays can make V2 truncate this one-line JSON to zero lines,
@@ -2952,8 +3086,24 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // packet can already contain one even while its Reviewer is still pending.
                 const { task: _dispatchTask, ...packet } = missionDispatchPacket(mission, previous);
                 const reviewPending = mission.runID === previous?.runID && mission.review?.verdict === "pending";
-                const active = mission.dispatchOpen || reviewPending || mission.runID === previous?.runID &&
-                    previous?.units.some(unit => unit.status === "running");
+                const running = mission.runID === previous?.runID ? previous.units.filter(unit => unit.status === "running") : [];
+                let retainedDirectOwnerEnded = false;
+                if (!mission.dispatchOpen && !reviewPending && mission.coordinator && running.length &&
+                    running.every(unit => unit.directExecution?.actor === mission.coordinator && !unit.reviewerCorrection)) {
+                    // This only forwards a proposal to the SAME owner. Native session termination
+                    // does not settle its retained unit or authorize a new writer/contract.
+                    const native = payload(await session("get", { path: { id: mission.coordinator } }).catch(() => undefined));
+                    if (record(native) && native.id === mission.coordinator && native.parentID === root &&
+                        canonicalAgent(profile, native.agent) === "dog-operator" &&
+                        ["succeeded", "failed", "interrupted"].includes(String(native.outcome))) {
+                        try {
+                            await assertDirectPlanningQuiescent(mission.coordinator);
+                            retainedDirectOwnerEnded = true;
+                        }
+                        catch { /* A live/unproven native tool still owns this work; do not offer another Task. */ }
+                    }
+                }
+                const active = mission.dispatchOpen || reviewPending || running.length > 0 && !retainedDirectOwnerEnded;
                 const continuation = !active ? missions.task(mission) : undefined;
                 // Existing Coordinator resumes accept a concrete prompt. Do not use the opaque
                 // initial reference here: claim() would expand it from unchanged Mission state
@@ -2975,25 +3125,23 @@ export function createProfiledPlugin(profile, assetVersion) {
             const same = previous?.planHash === createHash("sha256").update(JSON.stringify(plan)).digest("hex");
             const replanning = previous && !["completed", "cancelled"].includes(previous.phase) && !same;
             const activeDirect = previous?.units.find(unit => unit.status === "running" && unit.directExecution?.actor === actor);
-            const registrationChanged = activeDirect && JSON.stringify(activeDirect.directExecution.validationCwd ?? activeDirect.unit.validation_cwd ?? {}) !==
-                JSON.stringify(plan.units.find(unit => unit.id === activeDirect.unit.id)?.validation_cwd ?? {});
-            const registrationPlanHash = previous && activeDirect && createHash("sha256").update(JSON.stringify({ ...plan,
-                units: plan.units.map((unit, index) => {
-                    const prior = previous.units[index]?.unit;
-                    if (prior?.validation_cwd)
-                        return { ...unit, validation_cwd: prior.validation_cwd };
-                    const { validation_cwd: _cwd, ...rest } = unit;
-                    return rest;
-                }) })).digest("hex");
+            const nextRegistration = plan.units.find(unit => unit.id === activeDirect?.unit.id);
+            const registrationChanged = activeDirect && (JSON.stringify(unitValidationCwd(activeDirect) ?? {}) !==
+                JSON.stringify(nextRegistration?.validation_cwd ?? {}) ||
+                JSON.stringify(unitValidation(activeDirect)) !== JSON.stringify(nextRegistration?.validation));
+            const registrationPlanHash = previous && activeDirect && directValidationRegistrationPlanHash(previous, plan, activeDirect.unit.id);
             if (previous && activeDirect && (registrationChanged || replanning && registrationPlanHash === previous.planHash)) {
                 if (!reason?.trim())
                     throw new Error("mission-replan-reason-required: name the validation registration correction");
                 if (execution !== undefined && !emptyImplementationExecution)
                     throw new Error("mission-validation-registration-operation-change-forbidden");
+                await assertDirectPlanningQuiescent(actor, planningCallID);
                 const corrected = await operators.correctDirectValidationRegistration(root, actor, previous.runID, plan);
                 const unit = corrected.units.find(unit => unit.status === "running" && unit.directExecution?.actor === actor);
+                const last = unitValidation(unit).at(-1);
+                await control.registerDirectValidation(root, actor, unit.unit.id, last, unit.directExecution.validationRegisteredAt?.[last] ?? unit.directExecution.startedAt);
                 return JSON.stringify({ status: "direct-unit-registration-corrected", run_id: corrected.runID, unit_id: unit.unit.id,
-                    executor_session_id: actor, validation: unit.unit.validation, validation_cwd: unit.directExecution.validationCwd,
+                    executor_session_id: actor, validation: unitValidation(unit), validation_cwd: unitValidationCwd(unit),
                     registered_at: unit.directExecution.validationRegisteredAt,
                     next_action: `Run the affected declared checks in their registered cwd here, then ${finishDirectUnit}. Old observations remain historical; no new Task, terminal, reservation or benchmark attempt was created.` });
             }
@@ -3019,38 +3167,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         throw new Error(`mission-replan-terminal-unreconciled:${"reason" in terminal ? terminal.reason : "unknown"}`);
                 }
                 if (ownDirect) {
-                    // Cold hook state alone cannot prove quiescence. Require actual native tool records;
-                    // a completed background launch still owns a running process. Only this exact planner
-                    // call may be pending while it ends its own admission.
-                    const history = payload(await session("messages", { path: { id: actor }, query: { directory: input.directory } }));
-                    if (!Array.isArray(history))
-                        throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
-                    const calls = new Map();
-                    for (const message of history) {
-                        if (!record(message) || !record(message.info) || message.info.sessionID !== actor || !Array.isArray(message.parts)) {
-                            throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
-                        }
-                        for (const part of message.parts) {
-                            if (!record(part) || typeof part.type !== "string")
-                                throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
-                            if (part.type !== "tool")
-                                continue;
-                            if (part.callID === planningCallID && planningCallID && part.tool === planUnits)
-                                continue;
-                            if (typeof part.callID !== "string")
-                                throw new Error("mission-replan-terminal-unreconciled:tool_identity_unavailable");
-                            const prior = calls.get(part.callID);
-                            if (prior && prior.tool !== part.tool)
-                                throw new Error("mission-replan-terminal-unreconciled:tool_identity_conflict");
-                            calls.set(part.callID, part);
-                        }
-                    }
-                    for (const part of calls.values()) {
-                        if (!record(part.state) || !["completed", "error"].includes(String(part.state.status)) ||
-                            (record(part.state.metadata) && ["running", "pending", "unknown"].includes(String(part.state.metadata.status)))) {
-                            throw new Error("mission-replan-terminal-unreconciled:tool_dispatch_active_or_unproven");
-                        }
-                    }
+                    await assertDirectPlanningQuiescent(actor, planningCallID);
                     await activateDirect(actor);
                     await control.finishDirectUnit(root, actor, []);
                     previous = await operators.required(root);
@@ -3062,7 +3179,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             const cancelledPredecessor = previous?.phase === "cancelled" &&
                 (mission.supersededRunID === previous.runID ||
                     (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
-                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
+                        previous.units.some(unit => (previous?.decision === "agent-changed" || unit.status === "cancelled") &&
+                            (unit.childSessionID !== null || !unit.directExecution && unit.callID !== null))));
             let budget = await control.currentBudget(root);
             if (cancelledPredecessor && budget?.reserved_units) {
                 await control.reconcileAbortedOperatorOrphan(root);
@@ -3073,6 +3191,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // Reconcile it even when reservation recovery has nothing to do. Never resume it,
                 // interrupt live work here, or manufacture its native terminal/validation records.
                 await stopCancelledChildren(root, previous, true);
+                previous = await operators.required(root);
             }
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error(`mission-budget-exhausted: plan needs ${plan.units.length} units; ${budget.remaining_units} remain. ` +
@@ -3110,8 +3229,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 ...(previous ? { retained_validation: missionReviewValidation(previous, replanning || previous.phase === "completed"
                         ? operators.replanArchivePath(previous) : cancelledPredecessor ? `${operators.statePath(root)}.${previous.runID}.archive` : operators.statePath(root)),
                     prior_run_id: previous.runID } : {}) };
+            const terminalTaskCalls = cancelledPredecessor && previous ? await cancelledUnclaimedTaskCalls(root, previous) : undefined;
             const state = replanning && previous ? await operators.replanMission(root, previous.runID, plan, dispatcher, context)
-                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context);
+                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context, terminalTaskCalls);
             // prepareMission retains an identical prepared run after either registration stage
             // fails. Verify its pinned controls, then idempotently register the same declaration;
             // only the durable Mission binding below makes it eligible for admission.
@@ -3151,7 +3271,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 handoff_context: handoffContextSchema,
                 reason: { type: "string", "x-sortie-optional": true },
                 purpose_decision: purposeDecisionSchema,
-                executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here. Use worker without units to yield the current direct unit, carrying remaining action in handoff_context; the same unit, edits, checks and budget continue. With units, worker/default retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
+                executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here. Use executor=worker with units=\"\" in V2 (omit units in legacy; never units=[]) to yield the current direct unit, carrying remaining action in handoff_context; the same unit, edits, checks and budget continue. With units, worker/default retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 if (args.executor !== undefined && !["self", "worker"].includes(args.executor))
                     throw new Error("mission-executor-invalid");
@@ -3360,8 +3480,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                             objective: `${validationRecovery ? "The prior correction completed, but its inherited validation is now stale. Preserve completed implementation, reproduction, original findings and historical checks; refresh only affected checks in this selected author context. If the check recipe needs repair, use repair_review here as its actual author. Do not redo unchanged implementation/discovery or request a routine repeat Review. " : ""}Correct all retained concrete Major/Medium findings in this selected native conversation; preserve every original requirement, prior author and evidence binding. Exact findings are at correction_context.findings in the handoff; retained_findings_ref is optional lineage, not an instruction to reread/print the entire Mission or previous review prompt. Relevant search and focused diagnostics may widen normally; do not rediscover unchanged work. ${REVIEWER_VALIDATION_WORKFLOW} Retain the requested commit/clean boundary. THEN explicitly self-recheck the original requirements, ALL retained findings, correction and relevant impact in this Task. Correct known defects and revalidate affected checks before finishing. First line SELF_RECHECKED. Next line self_recheck: {"candidate":"current-validated","unresolved_findings":[],"residual_major":null}. The HOST binds current-validated to actual current source and fresh successful native checks after this exact prompt; never copy a pre-edit hash. Explain the actual comparison below. List unresolved concrete Major/Medium defects in unresolved_findings (no acceptance). Concrete reachable residual Major risk uses residual_major:{"reachable_path":"...","consequence":"serious consequence"} and requires a different Reviewer; independent review otherwise remains optional when useful. Tags/hashes/Medium/prose gaps alone never mandate it. This is author self-recheck, NOT independent PASS. Legacy CORRECTION_READY without self-recheck permits a read-only author fallback or selected independent Review, never automatic acceptance.`,
                             read: [...new Set([...(mission.reviewScope?.read ?? []), ...run.units.flatMap(unit => unit.unit.read)])],
                             write: [...new Set([...(mission.reviewScope?.write ?? []), ...run.units.flatMap(unit => unit.unit.write)])],
-                            validation: run.units.flatMap(unit => unit.unit.validation),
-                            validation_cwd: Object.assign({}, ...run.units.map(unit => unit.directExecution?.validationCwd ?? unit.unit.validation_cwd ?? {})) }], input.directory);
+                            validation: run.units.flatMap(unitValidation),
+                            validation_cwd: Object.assign({}, ...run.units.map(unit => unitValidationCwd(unit) ?? {})) }], input.directory);
                     // Inherit fixed declaration budgets and Git authority, never infer fresh capacity.
                     const goalPath = /^goal_declaration_path: (.+)$/mu.exec(run.units[0].task.prompt)?.[1];
                     if (!goalPath)
@@ -3369,7 +3489,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const declaration = JSON.parse(await readFile(goalPath, "utf8"));
                     const retainedPlan = { ...plan, acceptance: run.acceptance, acceptance_proof: run.acceptanceProof,
                         source_refs: run.sourceRefs, goal_declaration: declaration,
-                        units: [{ ...plan.units[0], validation: run.units.flatMap(unit => unit.unit.validation) }] };
+                        units: [{ ...plan.units[0], validation: run.units.flatMap(unitValidation) }] };
                     const correctedPlan = run.gitLifecycle ? { ...retainedPlan, git_lifecycle: {
                             branch_create: { branch: run.gitLifecycle.branch, start_ref: run.gitLifecycle.startRef },
                             commit: { message: run.gitLifecycle.commitMessage }, post_commit_validation: run.gitLifecycle.postCommitValidation,
@@ -3520,9 +3640,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                         }).catch(() => []) : [];
                     const initialPrompt = initialMissionReviewPrompt(mission, completed);
                     const phase = initialPrompt ? "verification" : "initial";
-                    const observedValidation = risk.length === 0 && !correction ? [] : await Promise.all(run.units.filter(unit => unit.unit.validation.length > 0).map(async (unit) => ({
+                    const observedValidation = risk.length === 0 && !correction ? [] : await Promise.all(run.units.filter(unit => unitValidation(unit).length > 0).map(async (unit) => ({
                         unit_id: unit.unit.id,
-                        ...observedMissionValidation(unit.unit.validation, unit.childSessionID, unit.childSessionID ? await messages(unit.childSessionID).catch(() => []) : [], unit.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? run.createdAt) : undefined, unit.reviewerCorrection || unit.directExecution ? input.directory : undefined, unit.directExecution?.validationCwd ?? unit.unit.validation_cwd),
+                        ...observedMissionValidation(unitValidation(unit), unit.childSessionID, unit.childSessionID ? await messages(unit.childSessionID).catch(() => []) : [], unit.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? run.createdAt) : undefined, unit.reviewerCorrection || unit.directExecution ? input.directory : undefined, unitValidationCwd(unit)),
                     })));
                     const task = risk.length === 0 && !correction && !selfRecheck && !independentRequested ? null : { subagent_type: profileAgent(profile, "dog-reviewer"),
                         ...(reviewerID ? { task_id: reviewerID } : {}),

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

@@ -47,6 +47,13 @@ export interface ReviewerCorrectionCheck {
     /** A command that actually generated/formatted declared outputs retains its stable input digest. */
     readonly generatedInputs?: string;
 }
+/** Live projection of reusable occurrences; never rewrites the saved native check. */
+export interface DirectHandoffValidationCheck extends ReviewerCorrectionCheck {
+    readonly matchedOccurrences: readonly {
+        readonly member: number;
+        readonly occurrence: number;
+    }[];
+}
 /** Exact durable Mission Task claim, not authority supplied by a tool argument or Read. */
 export interface MissionImplementationAdmission {
     readonly runID: string;
@@ -82,6 +89,8 @@ export interface RuntimeBridge {
     /** Only an exact admitted correction Task is an implementation dispatch continuing the original Reviewer child. */
     ownsReviewerCorrectionDispatch?(rootSessionID: string, callID: string, taskID: string): Promise<boolean>;
     ownsReviewerCorrection?(childSessionID: string): Promise<boolean>;
+    /** Native check capture only; does not grant Reviewer correction or artifact authority. */
+    ownsValidationRegistration?(childSessionID: string): Promise<boolean>;
     /** Existing controller executing a declared unit itself; never a fictitious native Task. */
     directMissionExecution?(sessionID: string): Promise<{
         root: string;
@@ -99,7 +108,7 @@ export interface RuntimeBridge {
             endedAt: string;
         }[];
     } | undefined>;
-    missionHandoffChecks?(rootSessionID: string, taskID: string, callID: string): Promise<readonly ReviewerCorrectionCheck[]>;
+    missionHandoffChecks?(rootSessionID: string, taskID: string, callID: string): Promise<readonly DirectHandoffValidationCheck[]>;
     reviewerCorrectionValidationMembers?(childSessionID: string, command: string, directory?: string): Promise<string[] | undefined>;
     missionValidationDirectoryMatches?(rootSessionID: string, taskID: string, childSessionID: string, commands: readonly string[], directory: string): Promise<boolean>;
     recordReviewerCorrectionCheck?(rootSessionID: string, taskID: string, check: ReviewerCorrectionCheck): Promise<void>;
@@ -156,6 +165,7 @@ export interface RuntimeBridge {
             currentTaskIDs: readonly string[];
         }): Promise<void>;
         registerGoalDeclaration(rootSessionID: string, prompt: string, missionRevision?: boolean): Promise<void>;
+        registerDirectValidation(rootSessionID: string, actor: string, criterionID: string, command: string, registeredAt: string): Promise<void>;
         relinkRegisteredGoal(rootSessionID: string, request: {
             prompt: string;
             expectedFingerprint: string;

package/dist/runtime-mission-assets.js

@@ -163,6 +163,18 @@ ${controls(profile, ["start_mission", "plan_units", "start_direct_unit", "finish
 You are Operator, the user-facing strategic authority. Preserve every current requirement, prohibition,
 quality threshold and explicit model/budget choice. Follow AGENTS.md and use the user's language.
 
+Own strategy, not just the relay of a stopped author's reply. At a method stall or proposed extra step,
+compare the user's goal, actual result and concrete unmet work. Continue planned useful work without
+intervention; suppress unnecessary expansion, and choose only the recovery needed for a real obstacle.
+Separate a required outcome/check from an AI-selected method. Do not promote your own checker, evidence
+format or procedure into an immutable user requirement. An AI-selected method already registered as
+formal validation still needs lawful recipe correction or replanning; never silently omit it or invent PASS.
+When a change of method is needed, give the existing author the concrete alternative, rationale and
+retained obligations, not merely "resume" or the same failing instruction. Use plan_units with proposed
+units, reason and handoff_context to obtain its concrete Coordinator continuation when available.
+Do not restart a release, cancel live work or take over implementation just to exercise strategic authority.
+Ordinary implementation decisions remain with the author; no per-Task approval or decision-record ritual.
+
 ${MISSION_DEPENDENCY_WORKFLOW}
 
 1. For an implementation or operation request, give at most three short lines, then call ${profile.toolPrefix}start_mission
@@ -195,7 +207,8 @@ ${MISSION_DEPENDENCY_WORKFLOW}
     an ordinary affirmative reply or a request to self-recover is enough. No hidden command or ID is
     needed from the user, and ordinary autonomous recovery does not require a new approval.
     Inspect operator_status to reconcile only native-proven ended work. If this session owns a quiescent
-    direct admission that cannot bind, plan_units with executor: "worker" and no units yields that same
+    direct admission that cannot bind, plan_units with executor: "worker" and units: "" in V2
+    (omit units on the legacy API; never units: []) yields that same
     unit and reservation without acquiring the contested writer. Explain the result and continue the
     returned Task when its write scope is available. A genuinely live or unproven other owner is not
     released: wait or separate work, and do not dispatch repeated conflicting attempts. Do not invent
@@ -545,14 +558,16 @@ Use the Operator's preferred_executor as a starting recommendation. Start useful
 do not investigate merely to confirm the recommendation. Adapt through actual work, honoring explicit user choices.
 Use plan_units with executor: "self" for direct work, or start_direct_unit for an already prepared unit.
 If a direct admission cannot bind because of manifest-overlap, operator_status and plan_units with
-executor: "worker" and no units remain management operations: yield only this quiescent owner, retain
+executor: "worker" and units: "" in V2 (omit units on the legacy API; never units: []) remain
+management operations: yield only this quiescent owner, retain
 its checks and reservation, and wait for a real conflicting writer rather than evicting it. Continue
 the same Mission and actual remaining work; do not create another Mission to clear the conflict.
 The host binds your native check results to the candidate; finish_direct_unit closes that work without
 a Worker handoff. Independent Review and Operator final acceptance still follow. This is not limited to
 micro-edits. Delegate to the configured Worker when that reduces work/cost or provides useful separation.
 There is no proposal/approval/contract-repair round trip in this route.
-To hand unfinished direct work to a Worker, call plan_units with executor: "worker", omit units, and put
+To hand unfinished direct work to a Worker, call plan_units with executor: "worker", units: "" in V2
+(omit units on the legacy API; never units: []), and put
 the remaining action/useful observations in handoff_context. The host transfers this same unit after current
 native commands settle, retaining changes, checks and budget. Do not finish it as successful or replan just
 to change its author. Dispatch the returned Task once; Operator recommendation does not prevent this choice.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",