sortie-dogs 0.13.2 → 0.13.3

package/README.md

@@ -14,6 +14,9 @@ implementation, validation, review, and model routing.
   continuation, remediation, and restart.
 - **Adaptive execution**: small work stays small; additional agents and stronger
   models are used only when task shape or risk justifies them.
+- **Clear Worker instructions**: give Luna a concise goal, explicit constraints
+  and completion criteria; keep orchestration bookkeeping in the harness.
+  See the [instruction design principles](docs/worker-instruction-design.md).
 - **Coexistence**: Sortie activates only when selected and preserves normal
   OpenCode agents, settings, and user-owned files.
 - **Cost, time, and proof**: the objective is a verified result at the lowest
@@ -78,6 +81,20 @@ internal children and must not be selected as task entry points.
 model routing. A new session alone does not reload an updated
 plugin process, so restart OpenCode after installation or upgrade.
 
+## v0.13.3 runtime updates
+
+The current release integrates native background Mission execution, concise authoritative Worker
+handoffs, and same-context Reviewer corrections from PRs #148/#149 and their Ubuntu remediation.
+After finding defects, the original Reviewer can correct and explicitly self-recheck in the same
+native session, retaining formal checks, current-source evidence, Git delivery and cumulative budget.
+Author self-recheck is recorded as non-independent; a different Reviewer is conditional on a concrete
+reachable residual Major risk. Unresolved Major or Medium findings still block acceptance.
+
+The installed native correction fixture succeeded, but the original Anko measurements remain
+unaccepted, including the latest 25-minute run. This release does not claim general speedup,
+original-task completion or a new SWE-bench score. See the [release notes](docs/release-v0.13.3.md)
+and [retained implementation and measurement history](docs/anko-pr149-ubuntu-handoff.md).
+
 ## v0.12.0 workflow
 
 v0.12.0 keeps Operator → Coordinator → Worker, with independent review:

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.13.2-anko-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.3-reviewer-context-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.13.2-anko-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.3-reviewer-context-v1";

package/dist/core/contract-limits.d.ts

@@ -6,3 +6,8 @@ export declare const CONTRACT_TEXT_LIMITS: Readonly<{
     command: 8192;
     path: 512;
 }>;
+/** New Mission task generation only; persisted/legacy contracts retain their original bounds. */
+export declare const MISSION_OBJECTIVE_LIMITS: Readonly<{
+    target: 2000;
+    maximum: 3000;
+}>;

package/dist/core/contract-limits.js

@@ -1,2 +1,4 @@
 /** Common text bounds shared by handoff, manifest and goal evidence validation. */
 export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 32768, statement: 1000, command: 8192, path: 512 });
+/** New Mission task generation only; persisted/legacy contracts retain their original bounds. */
+export const MISSION_OBJECTIVE_LIMITS = Object.freeze({ target: 2000, maximum: 3000 });

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

@@ -1,4 +1,4 @@
-import { type OperatorPlan, type OperatorState, type OperatorTask } from "./operator-runtime.js";
+import { type OperatorPlan, type OperatorState, type OperatorTask, type OperatorRuntime } from "./operator-runtime.js";
 import { type RuntimeProfile } from "./runtime-profile.js";
 export declare const MISSION_REFERENCE = "SORTIE_MISSION_REF ";
 export declare const MISSION_REVIEW_REFERENCE = "SORTIE_MISSION_REVIEW_REF ";
@@ -44,7 +44,7 @@ export interface MissionAttempt {
     predecessorAttemptID?: string | null;
     /** Fingerprint of the settled scoped candidate against which a later Rescue is proposed. */
     candidateID?: string;
-    kind: "implementation" | "normal_remediation" | "astra_rescue";
+    kind: "implementation" | "normal_remediation" | "astra_rescue" | "reviewer_correction";
     status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed";
     callID?: string;
     childSessionID?: string;
@@ -100,6 +100,24 @@ export interface MissionLaunchConditions {
     applies_to: string;
     recordedAt?: string;
 }
+/** Native terminal self-recheck by the correction author, explicitly not independent approval. */
+export interface MissionSelfRecheck {
+    runID: string;
+    source: string;
+    /** Candidate source/check identity, excluding optional excerpt presentation. */
+    candidateSource?: string;
+    author: string;
+    callID: string;
+    promptID: string;
+    messageID: string;
+    nativeOutcome: "completed";
+    result: string;
+    unresolvedFindings: string[];
+    residualMajor?: {
+        reachable_path: string;
+        consequence: string;
+    };
+}
 export interface OperatorMission {
     version: "0.12";
     id: string;
@@ -107,6 +125,12 @@ export interface OperatorMission {
     requests: MissionRequest[];
     /** Prior public conversation context, not additional immutable requirements. */
     context?: MissionContext[];
+    /** Explicit continue deliveries, keyed by the original real turn. */
+    steering?: {
+        requestID: string;
+        child: string;
+        status: "pending" | "queued";
+    }[];
     kind?: "implementation" | "operation";
     /** Native shell observations of the requested operation, separate from auxiliary checks. */
     execution?: MissionExecution;
@@ -152,17 +176,36 @@ export interface OperatorMission {
         runID: string;
         risk: string[];
         source: string;
+        candidateSource?: string;
         task: OperatorTask | null;
+        callID?: string;
         evidence?: MissionEvidenceExcerpt[];
         requestFingerprint?: string;
-        verdict: "pending" | "PASS" | "findings" | "evidence-gaps" | "skipped-low-risk";
+        verdict: "pending" | "PASS" | "findings" | "evidence-gaps" | "skipped-low-risk" | "self-rechecked";
         result?: string;
         child?: string;
+        mode?: "independent" | "self-recheck";
+        admittedAt?: number;
+        promptID?: string;
+        selfRecheck?: MissionSelfRecheck;
         /** Completed, independent initial review for this mission, not merely an inherited child ID. */
         initialPrompt?: string;
         /** Observed evidence-only reviews; reporting only, never an acceptance threshold. */
         evidenceGapReviews?: number;
     };
+    /** Retained independently of later review generations; authors never become independent reviewers. */
+    corrections?: {
+        author: string;
+        reviewIdentity: string;
+        priorRunID: string;
+        runID: string;
+        priorSource: string;
+        findings: string;
+        initialPrompt: string;
+        baseline?: string;
+        status: "prepared" | "running" | "ready" | "failed" | "cancelled";
+        selfRecheck?: MissionSelfRecheck;
+    }[];
 }
 export declare const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
@@ -171,6 +214,8 @@ export declare function missionReviewScope(previous: MissionReviewScope | undefi
 export declare function missionReviewVerdict(text: string): "PASS" | "evidence-gaps" | "findings";
 /** Whether the recorded review permits submission and acceptance of the current candidate. */
 export declare function missionReviewAccepted(review: NonNullable<OperatorMission["review"]>): boolean;
+/** A short native report, not a tag/hash-based second-review policy or an approval checklist. */
+export declare function missionSelfRecheckReport(text: string, source: string, hostBound?: boolean): Pick<MissionSelfRecheck, "unresolvedFindings" | "residualMajor"> | undefined;
 export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "running" | "execution-failed" | "executed";
 /** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,
  * not process success. Unstructured commands retain their native exit semantics. */
@@ -187,6 +232,7 @@ export declare class OperatorMissionRuntime {
     private readonly writes;
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
+    correctionReference(root: string, reviewIdentity: string): string;
     private load;
     /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     private loadMission;
@@ -228,7 +274,10 @@ export declare class OperatorMissionRuntime {
     brief(state: OperatorMission): string;
 }
 /** The model supplies only useful unit facts; IDs, proof projection and control documents are generated here. */
-export declare function missionPlan(mission: OperatorMission, raw: unknown): OperatorPlan;
+export declare function missionPlan(mission: OperatorMission, raw: unknown, projectRoot?: string): OperatorPlan;
+/** Compact provenance, not a new acceptance verdict or a substitute for original-request comparison. */
+export declare function missionAcceptanceSummary(mission: OperatorMission, run: OperatorState | undefined, operators: OperatorRuntime, observe?: (validation: readonly string[], child: string | null, notBefore?: number) => Promise<unknown>): Promise<Record<string, unknown>>;
+export declare function missionReviewIndependent(mission: OperatorMission, child: string | undefined): boolean;
 export declare function missionPacket(mission: OperatorMission, run?: OperatorState): Record<string, unknown>;
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export declare function missionReviewTask(mission: OperatorMission): OperatorTask;

package/dist/core/operator-mission.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { normalizeExecutionScope } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
@@ -34,9 +34,39 @@ export function missionReviewVerdict(text) {
 }
 /** Whether the recorded review permits submission and acceptance of the current candidate. */
 export function missionReviewAccepted(review) {
+    if (review.verdict === "self-rechecked") {
+        const checked = review.selfRecheck;
+        return review.mode === "self-recheck" && !!checked && checked.runID === review.runID &&
+            checked.source === review.source && checked.author === review.child && checked.callID === review.callID &&
+            checked.promptID === review.promptID && !!checked.messageID && checked.nativeOutcome === "completed" &&
+            checked.unresolvedFindings.length === 0 && !checked.residualMajor;
+    }
+    if (review.mode === "self-recheck")
+        return false;
     return review.verdict === "PASS" || review.verdict === "skipped-low-risk" ||
         review.verdict === "evidence-gaps";
 }
+/** A short native report, not a tag/hash-based second-review policy or an approval checklist. */
+export function missionSelfRecheckReport(text, source, hostBound = false) {
+    if (!/^\s*SELF_RECHECKED(?:\s|$)/u.test(text))
+        return undefined;
+    const line = /^self_recheck: (.+)$/mu.exec(text)?.[1];
+    try {
+        const report = JSON.parse(line ?? "");
+        if (!record(report) || (report.candidate !== source && !(hostBound && report.candidate === "current-validated")) || !Array.isArray(report.unresolved_findings) ||
+            !report.unresolved_findings.every(item => typeof item === "string" && item.trim()) ||
+            !(report.residual_major === null || record(report.residual_major) &&
+                typeof report.residual_major.reachable_path === "string" && report.residual_major.reachable_path.trim() &&
+                typeof report.residual_major.consequence === "string" && report.residual_major.consequence.trim()))
+            return undefined;
+        return { unresolvedFindings: report.unresolved_findings,
+            ...(record(report.residual_major) ? { residualMajor: { reachable_path: report.residual_major.reachable_path,
+                    consequence: report.residual_major.consequence } } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
         return "not-required";
@@ -100,6 +130,9 @@ export class OperatorMissionRuntime {
     file(root, suffix = "") {
         return join(this.projectRoot, this.profile.stateDirectory, "missions", `${digest(root)}${suffix}.json`);
     }
+    correctionReference(root, reviewIdentity) {
+        return JSON.stringify({ path: this.file(root), field: "corrections[]", review_identity: reviewIdentity });
+    }
     async load(file) {
         try {
             return JSON.parse(await readFile(file, "utf8"));
@@ -209,11 +242,6 @@ export class OperatorMissionRuntime {
         await this.serial(root, async () => {
             // Captured before prompt rewriting, including exact whitespace. Never ask a model to recopy it.
             await this.save(this.file(root, ".request"), request);
-            const state = await this.loadMission(root);
-            if (state && !["completed", "cancelled"].includes(state.phase) && !state.requests.some(item => item.id === request.id)) {
-                state.requests.push(request);
-                await this.save(this.file(root), state);
-            }
         });
     }
     recordLaunchConditions(root, raw) {
@@ -249,6 +277,9 @@ export class OperatorMissionRuntime {
                     throw new Error("mission-requirements-preserved: keep the existing ordered requirements and append user additions");
                 }
                 previous.requirements = requirements.map((text, index) => ({ id: `R${index + 1}`, text }));
+                // Only an explicit Mission action adopts the latest real turn; chat capture alone never does.
+                if (!previous.requests.some(item => item.id === request.id))
+                    previous.requests.push(request);
                 if (options.kind === "operation")
                     previous.kind = "operation";
                 await this.save(this.file(root), previous);
@@ -395,7 +426,7 @@ export class OperatorMissionRuntime {
     }
 }
 /** The model supplies only useful unit facts; IDs, proof projection and control documents are generated here. */
-export function missionPlan(mission, raw) {
+export function missionPlan(mission, raw, projectRoot) {
     if (!Array.isArray(raw) || raw.length === 0 || raw.length > 32)
         throw new Error("mission-units: declare 1..32 units");
     const acceptance = mission.requirements.map(item => item.text);
@@ -411,7 +442,12 @@ export function missionPlan(mission, raw) {
             const entries = value[field] ?? [];
             if (!Array.isArray(entries) || !entries.every(item => typeof item === "string"))
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
-            return [...new Set(entries.map(item => normalizeExecutionScope(item)))];
+            return [...new Set(entries.map(item => {
+                    // A model's repository-root read means the current project, not an invalid empty path.
+                    // Resolve only this read shorthand at the host boundary; saved plans and write scopes stay exact.
+                    const rootRead = field === "read" && [".", "./", ".\\", "./**", ".\\**"].includes(item);
+                    return normalizeExecutionScope(rootRead && projectRoot ? `${resolve(projectRoot).replaceAll("\\", "/")}/**` : item);
+                }))];
         };
         // A sole unit owns the whole request. This schedules work; it does not prove acceptance.
         const ids = value.requirement_ids ?? (raw.length === 1 || mission.requirements.length === 1 ? mission.requirements.map(item => item.id) : []);
@@ -423,9 +459,8 @@ export function missionPlan(mission, raw) {
             throw new Error(`mission-unit-${index + 1}: validation must contain exact commands; final command proves the unit`);
         }
         const validation = value.validation.map(missionValidationCommand);
-        // Retain last occurrences so removing a redundant check preserves the final proof command.
         return { id: `unit-${index + 1}`, title: line("title"), objective: line("objective"), read: paths("read"), write: paths("write"),
-            validation: validation.filter((command, i) => validation.lastIndexOf(command) === i),
+            validation,
             acceptance_indices: [...new Set(ids.map(id => mission.requirements.findIndex(item => item.id === id)))] };
     });
     // The serial engine counts new proof milestones. Units sharing the same final suite are one
@@ -441,7 +476,7 @@ export function missionPlan(mission, raw) {
         same.read = [...new Set([...same.read, ...unit.read])];
         same.write = [...new Set([...same.write, ...unit.write])];
         same.acceptance_indices = [...new Set([...same.acceptance_indices, ...unit.acceptance_indices])];
-        same.validation = [...new Set([...same.validation.slice(0, -1), ...unit.validation])];
+        same.validation = [...same.validation, ...unit.validation];
     }
     const uncovered = mission.requirements.filter((_, i) => !units.some(unit => unit.acceptance_indices.includes(i)));
     if (uncovered.length)
@@ -459,6 +494,73 @@ export function missionPlan(mission, raw) {
                 entrypoint: (unit.write[0] ?? unit.read[0] ?? unit.id).slice(0, 512), validation_command: unit.validation.at(-1) })) },
         units }, "execution");
 }
+/** Compact provenance, not a new acceptance verdict or a substitute for original-request comparison. */
+export async function missionAcceptanceSummary(mission, run, operators, observe) {
+    const current = run?.runID === mission.runID ? run : undefined;
+    const history = current ? await operators.acceptanceHistory(current, [...new Set((mission.attempts ?? []).map(item => item.runID))])
+        : { status: "unavailable", runs: [], reason: "current-mission-run-unavailable" };
+    const acceptedAnchor = (unit) => current?.priorAcceptedUnits.find(item => item.handoffPath === unit.handoffPath &&
+        item.handoffHash === unit.hashes[0] && item.taskID === unit.task.prompt.match(/^task_id: (.+)$/mu)?.[1]);
+    const missingAnchors = current?.priorAcceptedUnits.filter(anchor => !history.runs.some(item => item.state.units.some(unit => unit.status === "succeeded" && acceptedAnchor(unit)?.taskID === anchor.taskID))) ?? [];
+    const validation = (state, path, historical) => state.units.flatMap(unit => {
+        const anchor = historical ? acceptedAnchor(unit) : undefined;
+        if (historical && (!anchor || unit.status !== "succeeded"))
+            return [];
+        return (unit.evidence ?? []).map(proof => ({ run_id: state.runID, unit_id: unit.unit.id,
+            task_id: unit.task.prompt.match(/^task_id: (.+)$/mu)?.[1] ?? null,
+            worker_session_id: unit.childSessionID, state_archive_path: path, handoff_path: unit.handoffPath,
+            ...(anchor ? { accepted_anchor: anchor } : {}), evidence_id: proof.evidence_id,
+            command: proof.execution.command, exit: proof.execution.exit_code, outcome: proof.execution.outcome,
+            started_at: proof.execution.started_at, ended_at: proof.execution.ended_at,
+            identity: proof.identity,
+            ...(proof.protected_binding ? { binding_hashes: { manifest_hash: proof.protected_binding.manifest_hash,
+                    ...(proof.protected_binding.freshness ? { contract_hash: proof.protected_binding.freshness.contract_hash } : {}) },
+                operation_manifest_path: proof.protected_binding.manifest_path } : {}),
+            details_ref: { path: path ?? operators.statePath(state.rootSessionID),
+                unit_id: unit.unit.id, evidence_id: proof.evidence_id,
+                omitted: "protected_binding path arrays, project root and environment remain in this exact persisted evidence record" },
+            proof_scope: proof.proof_scope,
+            applicability: historical ? "historical-reference; current applicability not established by this projection"
+                : "current-run record; consult completion readiness for current protected identity" }));
+    });
+    const nativeValidation = await Promise.all([
+        ...(current ? [{ path: null, state: current, historical: false }] : []),
+        ...history.runs.map(item => ({ ...item, historical: true })),
+    ].flatMap(item => item.state.units.filter(unit => !item.historical ||
+        (unit.status === "succeeded" && acceptedAnchor(unit))).map(async (unit) => {
+        const provenance = { run_id: item.state.runID, unit_id: unit.unit.id, worker_session_id: unit.childSessionID,
+            state_archive_path: item.path, handoff_path: unit.handoffPath, historical: item.historical,
+            authority: "native declared-command observations; not additional formal evidence or current freshness" };
+        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.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? item.state.createdAt) : undefined) };
+        }
+        catch (error) {
+            return { ...provenance, status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+        }
+    })));
+    return { original_requests: mission.requests, requirements: mission.requirements,
+        history: { status: missingAnchors.length ? "unavailable" : history.status,
+            ...(history.reason ? { reason: history.reason } : missingAnchors.length ? { reason: "accepted-handoff-anchor-unavailable" } : {}),
+            ...(missingAnchors.length ? { unavailable_anchors: missingAnchors } : {}),
+            selection: "same-mission Worker run IDs, parent lineage and exact accepted handoff anchors" },
+        formal_validation: [...(current ? validation(current, null, false) : []),
+            ...history.runs.flatMap(item => validation(item.state, item.path, true))],
+        native_declared_validation: nativeValidation,
+        independent_review: mission.review ? { run_id: mission.review.runID, current_run: mission.review.runID === current?.runID,
+            independent: missionReviewIndependent(mission, mission.review.child), mode: mission.review.mode ?? "independent",
+            reviewer_session_id: mission.review.child ?? null, source_fingerprint: mission.review.source,
+            verdict: mission.review.verdict, result: mission.review.result ?? null, self_recheck: mission.review.selfRecheck ?? null,
+            freshness: "not established by run ID; existing source comparison remains required" } : null,
+        delivery: { submission: mission.submission, git_lifecycle: current?.gitLifecycle ?? null,
+            observation_source: "persisted operator Git lifecycle and formal validation records; no new Git inspection",
+            clean: "not independently observed by this projection" },
+        interpretation: "Compare original requests with the submitted candidate and actual evidence. Historical PASS is not current PASS. Inspect concrete gaps, not routine archive searches or full source rereads. Existing completion and Review guards still apply." };
+}
+export function missionReviewIndependent(mission, child) {
+    return child !== undefined && !(mission.corrections ?? []).some(correction => correction.author === child);
+}
 export function missionPacket(mission, run) {
     const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;
     if (predecessor)
@@ -473,9 +575,9 @@ export function missionPacket(mission, run) {
                 note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
         launch_conditions: mission.launchConditions ?? [], prohibited_write: mission.prohibitedWrite ?? [],
-        accounting_scope: "Worker units are not benchmark attempts. Host budget is Worker-only; orchestration, Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
+        accounting_scope: "Implementation units (Worker or scoped Reviewer correction) are not benchmark attempts. Host budget uses the existing Worker-unit ledger; orchestration, read-only Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
         submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
-        attempts: mission.attempts ?? [], ...(mission.rescue ? { rescue: mission.rescue } : {}),
+        attempts: mission.attempts ?? [], corrections: (mission.corrections ?? []).map(({ findings: _findings, initialPrompt: _prompt, ...item }) => item), ...(mission.rescue ? { rescue: mission.rescue } : {}),
         operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),
             ...(mission.execution ? { ...mission.execution } : {}) },
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
@@ -485,6 +587,8 @@ export function missionPacket(mission, run) {
             historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,
             accepted: mission.phase === "completed" },
         review: mission.review ? { risk_tags: mission.review.risk, verdict: mission.review.verdict,
+            independent: missionReviewIndependent(mission, mission.review.child), mode: mission.review.mode ?? "independent",
+            self_recheck: mission.review.selfRecheck ?? null,
             run_id: mission.review.runID, current_run: currentReview,
             source_fingerprint: mission.review.source, reviewer_session_id: mission.review.child ?? null,
             result: mission.review.result ?? null, evidence_gap_reviews: mission.review.evidenceGapReviews ?? 0,
@@ -500,22 +604,30 @@ export function missionPacket(mission, run) {
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"
-                ? "Operator: compare the submitted candidate with the original requirements and actual evidence, then complete_mission if satisfied. Report remaining evidence gaps; they are not a review PASS."
-                : mission.kind === "operation" && operationStatus === "running"
-                    ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
-                    : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
-                        ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
-                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
-                            ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
-                            : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
-                                ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
-                                : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                        : run?.phase === "awaiting-acceptance" && !operationComplete
-                            ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
-                            : run?.phase === "awaiting-acceptance" ? (reviewAccepted
-                                ? "Coordinator: review permits submission. Retain advisory review notes; do not repeat passed validation or review for evidence formatting. Operator performs final acceptance against the original requirements."
-                                : "Coordinator: address recorded findings or obtain the required independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
-                                : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
+                ? "Operator: use acceptance_summary to compare the submitted candidate with the verbatim original requests and actual evidence, inspect concrete gaps only, then complete_mission if satisfied. Do not routinely search archives or reread all source. Historical PASS is not current PASS. Report remaining evidence gaps; they are not a review PASS."
+                : run?.phase === "awaiting-acceptance" && mission.corrections?.some(item => item.runID === run.runID && item.status === "ready") && !reviewAccepted
+                    ? mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.unresolvedFindings.length
+                        ? "Known Major/Medium findings remain after self-recheck. Call repair_review for the SAME original correction owner; do not dispatch another Reviewer or accept unresolved Medium. Retain original requirements and cumulative spend."
+                        : mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.residualMajor
+                            ? "A concrete reachable Major risk remains after native author self-recheck. Call review_mission for a DIFFERENT Reviewer of the correction, retained findings and relevant impact; dispatch the exact returned Task if not already active. No fresh Worker or unchanged validation is required."
+                            : "Correction ready; call review_mission for the SAME native author to explicitly self-recheck the retained findings, relevant impact and original requirements. Only a concrete reachable Major risk remaining after self-recheck requires a DIFFERENT Reviewer. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
+                    : mission.kind === "operation" && operationStatus === "running"
+                        ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
+                        : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
+                            ? "Correction validation or native execution failed. Call repair_review for a new admission in the SAME original Reviewer's native session; fix its own regression, rerun inherited checks and retain the commit/clean boundary and cumulative spend. Do not use ordinary retry, Rescue or a fresh Worker replan. Failure is never acceptance."
+                            : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
+                                ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
+                                : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
+                                    ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
+                                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
+                                        ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
+                                        : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
+                                : run?.phase === "awaiting-acceptance" && !operationComplete
+                                    ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
+                                    : run?.phase === "awaiting-acceptance" ? (reviewAccepted
+                                        ? "Coordinator: review permits submission. Retain advisory review notes; do not repeat passed validation or review for evidence formatting. Operator performs final acceptance against the original requirements."
+                                        : "Coordinator: correct known Major/Medium findings, then obtain explicit native author self-recheck (different Reviewer only for residual concrete Major risk), or initial independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
+                                        : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export function missionReviewTask(mission) {

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

@@ -113,6 +113,15 @@ interface UnitState {
     status: "pending" | "running" | "succeeded" | "failed" | "cancelled";
     callID: string | null;
     childSessionID: string | null;
+    /** A scoped implementation continuation in the original native Reviewer, never a review PASS. */
+    reviewerCorrection?: {
+        author: string;
+        reviewIdentity: string;
+        writeUnion: readonly string[];
+        admittedAt?: string;
+        promptID?: string;
+        checks?: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
+    };
     evidence: readonly GoalEvidence[];
     resultClass: string | null;
     failure?: SerialDispatchSettlement["failure"];
@@ -257,6 +266,17 @@ export declare class OperatorRuntime {
     readonly projectRoot: string;
     constructor(projectRoot: string, profile: RuntimeProfile, gitPath?: string);
     private file;
+    /** Exact persisted source for read-only status projections. */
+    statePath(root: string): string;
+    /** Read-only lineage projection. Never imports archived evidence into current acceptance. */
+    acceptanceHistory(state: OperatorState, missionRunIDs: readonly string[]): Promise<{
+        status: "available" | "unavailable";
+        runs: {
+            path: string;
+            state: OperatorState;
+        }[];
+        reason?: string;
+    }>;
     read(root: string): Promise<OperatorState | undefined>;
     private save;
     private serial;
@@ -289,6 +309,12 @@ export declare class OperatorRuntime {
         sessionID: string;
         callID: string;
     }, context?: Record<string, unknown>): Promise<OperatorState>;
+    prepareReviewerCorrection(root: string, runID: string, raw: unknown, author: string, reviewIdentity: string, writeUnion: readonly string[], dispatcher?: {
+        sessionID: string;
+        callID: string;
+    }, context?: Record<string, unknown>): Promise<OperatorState>;
+    recordReviewerCorrectionCheck(root: string, taskID: string, check: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck): Promise<void>;
+    bindReviewerCorrectionPrompt(root: string, child: string, callID: string, promptID: string): Promise<void>;
     private prepareOnce;
     operatorTask(state: OperatorState): OperatorTask;
     /** Root-visible handle for the bounded operations delegate; its contract stays host-internal. */