sortie-dogs 0.16.0 → 0.16.2

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.0-purpose-aligned-v2";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.2-direct-validation-registration-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.0-purpose-aligned-v2";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.2-direct-validation-registration-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;

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;
@@ -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");
@@ -1467,14 +1480,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 +1624,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 +1644,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 +2382,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 +2412,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 [];
 }
@@ -683,12 +688,66 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
             local.push(scoped || ".");
     }
     const toolInput = scope.read.some(path => normalizeManifestScope(path).path.startsWith(TOOL_ENVIRONMENT));
-    const gitScopes = [...local, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
+    // A Location may inherit an ancestor repository while its actual outputs live in a
+    // nested repository/worktree. Resolve that boundary before asking the outer Git:
+    // ls-files can return the whole ignored repository (or fail internally) for a narrow output.
+    const rootLocal = [], nested = new Map();
+    for (const path of local) {
+        let current = resolve(directory), repository;
+        for (const part of path.split("/")) {
+            current = resolve(current, part);
+            const info = await lstat(current).catch((error) => {
+                if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
+                    throw error;
+                return undefined;
+            });
+            if (!info?.isDirectory())
+                break; // Missing files and symlink targets are not traversed.
+            if (current === resolve(directory))
+                continue;
+            const metadata = await lstat(join(current, ".git")).catch((error) => {
+                if (error.code !== "ENOENT")
+                    throw error;
+                return undefined;
+            });
+            if (metadata)
+                repository = current; // Includes .git files and broken worktrees: Git must diagnose them.
+        }
+        if (repository)
+            nested.set(repository, [...(nested.get(repository) ?? []), relative(repository, resolve(directory, path)).replaceAll("\\", "/") || "."]);
+        else
+            rootLocal.push(path);
+    }
+    const gitScopes = [...rootLocal, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
     const git = async (args) => (await exec("git", args, { cwd: directory, maxBuffer: 8 * 1024 * 1024 })).stdout;
     let names = "", ignored = "", repository = true, scopedDiff = "";
     const untracked = new Set(), currentFiles = new Set();
+    const collected = new Set();
+    const collectRepository = async (absolute, path, pathspec) => {
+        const scopedGit = async (args) => (await exec("git", args, { cwd: absolute, maxBuffer: 8 * 1024 * 1024 })).stdout;
+        const tracked = await scopedGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspec]);
+        const prefix = (name) => join(path, name).replaceAll("\\", "/");
+        for (const name of tracked.split("\0").filter(Boolean)) {
+            collected.add(prefix(name));
+            currentFiles.add(prefix(name));
+        }
+        for (const name of (await scopedGit(["ls-files", "-z", "--others", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean))
+            untracked.add(prefix(name));
+        for (const name of (await scopedGit(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean)) {
+            collected.add(prefix(name));
+            untracked.add(prefix(name));
+        }
+        // The Mission baseline belongs to its root, not these different repositories.
+        // Without a baseline here, committed outputs still appear as current content.
+        const delta = await currentGitDiff(scopedGit, pathspec);
+        if (delta)
+            scopedDiff += `\n--- repository output: ${path} ---\n${delta}`;
+    };
+    for (const [absolute, paths] of nested) {
+        await collectRepository(absolute, relative(directory, absolute).replaceAll("\\", "/"), paths);
+    }
     try {
-        if (local.length) {
+        if (rootLocal.length) {
             names = await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...gitScopes]);
             for (const path of (await git(["ls-files", "-z", "--others", "--exclude-standard", "--", ...gitScopes])).split("\0").filter(Boolean))
                 untracked.add(path);
@@ -701,7 +760,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         repository = false;
         // Mission storage can be outside Git while its declared outputs are repositories,
         // worktrees or plain files. Inventory those outputs in place, not the storage root.
-        const collected = new Set(), walked = new Set();
+        const walked = new Set();
         const collect = async (path) => {
             if (walked.has(path) || excluded(path))
                 return;
@@ -719,11 +778,9 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
                 untracked.add(path);
                 return;
             }
-            const scopedGit = async (args) => (await exec("git", args, { cwd: absolute, maxBuffer: 8 * 1024 * 1024 })).stdout;
-            const pathspec = ["."]; // Shared tooling is rooted at the Mission, not each output repository.
-            let tracked;
+            // Shared tooling is rooted at the Mission, not each output repository.
             try {
-                tracked = await scopedGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspec]);
+                await collectRepository(absolute, path, ["."]);
             }
             catch (error) {
                 if (!notRepository(error))
@@ -733,27 +790,11 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
                 }
                 return;
             }
-            const prefix = (name) => join(path, name).replaceAll("\\", "/");
-            for (const name of tracked.split("\0").filter(Boolean)) {
-                collected.add(prefix(name));
-                currentFiles.add(prefix(name));
-            }
-            for (const name of (await scopedGit(["ls-files", "-z", "--others", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean))
-                untracked.add(prefix(name));
-            for (const name of (await scopedGit(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean)) {
-                collected.add(prefix(name));
-                untracked.add(prefix(name));
-            }
-            // The mission's baseline belongs to its root, not to these different repositories.
-            // With no baseline here, committed outputs still appear as current file content.
-            const delta = await currentGitDiff(scopedGit, pathspec);
-            if (delta)
-                scopedDiff += `\n--- repository output: ${path} ---\n${delta}`;
         };
-        for (const path of local)
+        for (const path of rootLocal)
             await collect(path);
-        names = [...collected].sort().join("\0");
     }
+    names = [...new Set([...names.split("\0").filter(Boolean), ...collected])].sort().join("\0");
     // Go's ignored in-project caches may be writable during validation but are not candidate
     // output. Keep every other ignored declared output visible and fingerprinted, including
     // directories of generated artifacts; focused references can still pin a cache file.
@@ -763,7 +804,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
     const unreadable = [];
     const outsideLinks = [];
     let diff = scopedDiff;
-    if (repository && local.length && displayBaseline) {
+    if (repository && rootLocal.length && displayBaseline) {
         // HEAD-only diffs are empty once the author commits. Display the original mission delta
         // or the focused correction delta without changing the full fingerprint basis.
         const changed = (await git(["diff", "--name-only", "-z", "--no-ext-diff", displayBaseline, "--", ...gitScopes]))
@@ -774,7 +815,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         const available = Math.max(0, 24_000 - Buffer.byteLength(selected + heading) -
             headers.reduce((size, title) => size + Buffer.byteLength(title), 0) - 500);
         const allowance = shown.length ? Math.min(3_000, Math.floor(available / shown.length)) : 0;
-        diff = heading;
+        diff += heading;
         for (const [index, path] of shown.entries()) {
             const patch = await git(["diff", "--no-ext-diff", "--no-textconv", displayBaseline, "--", path]);
             const bytes = Buffer.from(patch);
@@ -788,8 +829,8 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         }
         omitted.push(...changed.slice(shown.length));
     }
-    else if (repository && local.length) {
-        diff = await currentGitDiff(git, gitScopes);
+    else if (repository && rootLocal.length) {
+        diff += await currentGitDiff(git, gitScopes);
     }
     const unchanged = diff.length === 0;
     let excerpt = selected + diff;

package/dist/plugin/native-background.d.ts

@@ -25,6 +25,7 @@ export declare class NativeBackgroundLifecycle {
     private readonly recoverResult?;
     private readonly operations;
     private readonly restored;
+    private readonly reconciliationErrors;
     constructor(context: OpenCodeV2Context, settle: (dispatch: NativeBackgroundDispatch, text: string) => Promise<string | void>, owner?: ((callID: string, restore?: ObjectValue) => ObjectValue | undefined) | undefined, recoverResult?: ((parent: string, callID: string, child: string, promptID?: string) => Promise<string | undefined>) | undefined);
     private serial;
     private read;
@@ -33,6 +34,7 @@ export declare class NativeBackgroundLifecycle {
     bind(parent: string, child: string, agent: string, prompt: string, promptID?: string): Promise<void>;
     launched(parent: string, callID: string, child: string | undefined, running: boolean): Promise<boolean>;
     awaiting(sessionID: string): Promise<boolean>;
+    reconciliationNotice(parent: string): string | undefined;
     reconcile(parent: string): Promise<void>;
     /** Add provenance beside its existing native notification, without editing history or waking the parent again. */
     project(parent: string, messages: readonly unknown[]): Promise<unknown[]>;

package/dist/plugin/native-background.js

@@ -9,6 +9,7 @@ export class NativeBackgroundLifecycle {
     recoverResult;
     operations = new Map();
     restored = new Set();
+    reconciliationErrors = new Map();
     constructor(context, settle, owner, recoverResult) {
         this.context = context;
         this.settle = settle;
@@ -85,8 +86,22 @@ export class NativeBackgroundLifecycle {
         return object(info) && typeof info.parentID === "string" &&
             (await this.read(info.parentID)).some(item => !item.settled && item.child === sessionID);
     }
+    reconciliationNotice(parent) { return this.reconciliationErrors.get(parent); }
     async reconcile(parent) {
-        await this.serial(parent, async () => this.reconcileInside(parent, await this.read(parent)));
+        try {
+            await this.serial(parent, async () => this.reconcileInside(parent, await this.read(parent)));
+            this.reconciliationErrors.delete(parent);
+        }
+        catch (error) {
+            // This is recovery of existing native work, not admission or acceptance. A failed
+            // inspection must retain its terminal/reservation for idempotent retry without
+            // making the next user prompt, model request or compaction fail before it starts.
+            const reason = error instanceof Error ? error.message : String(error);
+            console.warn("[sortie-dogs-v010] Background reconciliation unavailable; saved work retained", reason);
+            this.reconciliationErrors.set(parent, `SORTIE_BACKGROUND_RECONCILIATION_UNAVAILABLE\n${JSON.stringify(reason.slice(0, 2_000))}\n` +
+                "Native work/results and cumulative spend are retained; formal validation and acceptance are not proven by this recovery failure. " +
+                "Diagnose the failed inspection and reconcile this same invocation after repair. Do not relaunch or repeat an already completed external operation just to repair accounting.");
+        }
     }
     /** Add provenance beside its existing native notification, without editing history or waking the parent again. */
     async project(parent, messages) {

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" };
@@ -1920,7 +1955,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 +2043,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 +2319,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 +2352,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 +2361,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 +2469,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,
@@ -2975,25 +3054,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 +3096,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);
@@ -3151,7 +3197,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 +3406,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 +3415,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 +3566,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/plugin/v2.js

@@ -847,6 +847,9 @@ async function registerV2Hooks(context, hooks, background, liveState) {
                 event.messages = await background.project(String(event.sessionID ?? ""), event.messages);
             const output = { system: [] };
             await hooks["experimental.chat.system.transform"]({ sessionID: String(event.sessionID ?? "") }, output);
+            const reconciliation = background.reconciliationNotice(String(event.sessionID ?? ""));
+            if (reconciliation)
+                (output.system ??= []).push(reconciliation);
             await reconcileCorrectionPermissions(String(event.sessionID));
             if (record(event.tools)) {
                 const correcting = correctionAgent(event.agent) && !!await hooks.reviewerCorrectionScope?.(String(event.sessionID));
@@ -913,6 +916,9 @@ async function registerV2Hooks(context, hooks, background, liveState) {
                 }
             const output = { context: [] };
             await hooks["experimental.session.compacting"]({ sessionID: String(event.sessionID ?? "") }, output);
+            const reconciliation = background.reconciliationNotice(String(event.sessionID ?? ""));
+            if (reconciliation)
+                (output.context ??= []).push(reconciliation);
             if (Array.isArray(event.system))
                 event.system.push(...output.context.map(text => ({ type: "text", text })));
         });

package/dist/runtime-mission-assets.js

@@ -195,7 +195,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 +546,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.0",
+  "version": "0.16.2",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",