sortie-dogs 0.12.25 → 0.13.1

package/README.md

@@ -1,5 +1,9 @@
 # Sortie-dogs
 
+<p align="center">
+  <img src="docs/assets/sortie-dogs-logo.png" alt="Sortie-dogs logo" width="640">
+</p>
+
 **A goal-preserving, adaptive execution harness for OpenCode that optimizes cost,
 time, and proof without taking your setup over.**
 
@@ -28,6 +32,14 @@ implementation, validation, review, and model routing.
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) ·
 [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
+## SWE-bench Lite: 170/300 (56.67%)
+
+The fixed **Sortie-dogs v0.12.24** harness resolved **170 of 300 SWE-bench Lite test issues** in one pass@1 campaign, with 9 empty patches and no official evaluation errors. Every instance has a frozen prediction and an inference-time trajectory. The task Workers ran `openai/gpt-6-luna-fast#max`; operator, coordinator and review roles ran `openai/gpt-6-sol#xhigh`. This is a system result, **not** a Luna-only model comparison or a Verified/full SWE-bench score.
+
+[Technical report and per-repository results](docs/benchmarks/swebench-lite-v01224-test300-2026-09-29.md) · [Public predictions, logs and trajectories](https://github.com/zufall-upon/sortie-dogs-swebench-lite-20260929)
+
+The single official 300-instance report and frozen predictions are hash-bound in the report. Confirmed inference expense was **$162.99**; a separate **$34.60** of usage has unknown pricing and is held against the campaign cap, **not** counted as known expense. Leaderboard registration and maintainer acceptance are separate from this official local evaluation.
+
 > **Beta:** v0.12.2 builds on the v0.10.23 execution engine. Runtime behavior,
 > configuration, and generated assets may still change before 1.0.
 
@@ -202,7 +214,7 @@ not invent, probe, or translate variant names.
 - `freeTierFallbackModels`: ordered global last-resort model IDs. Default:
   `opencode/deepseek-v4-flash-free`; `[]` disables this fallback.
 - `dedicatedWorkerModel`: canonical stable serial target, default
-  `openai/gpt-6-sol` / `medium`. The v0.10 profile also supplies its explicit
+  `openai/gpt-6.1-sol` / `medium`. The v0.10 profile also supplies its explicit
   role routes below; do not infer the v0.10 worker route from this stable setting.
 - `consultation.strategy`: fixed advisor identity, optional `required`, and
   positive `maxCallsPerCandidate`; default one call and not required.
@@ -239,14 +251,14 @@ or explicit risk. Workers own static, targeted, and related checks; the root own
 canonical and full-suite checks. An unchanged candidate, command, and environment
 reuse the same evidence instead of spending the validation budget again.
 
-### Default v0.12 routes
+### Default routes
 
-- `dog-operator`: `openai/gpt-6-sol` / `xhigh`
-- `dogs-coordinator`: `openai/gpt-6-sol` / `xhigh`
+- `dog-operator`: `openai/gpt-6.1-sol` / `xhigh`
+- `dogs-coordinator`: `openai/gpt-6.1-sol` / `xhigh`
 - `dog-worker-v010`: `openai/gpt-6-luna-fast` / `max`
 - `dog-scout-v010`: `openai/gpt-6-luna-fast` / `max`
-- `dog-reviewer-v010`: `openai/gpt-6-sol` / `xhigh`
-- `dog-advisor-v010`: `openai/gpt-6-sol` / `xhigh`
+- `dog-reviewer-v010`: `openai/gpt-6.1-sol` / `xhigh`
+- `dog-advisor-v010`: `openai/gpt-6.1-sol` / `xhigh`
 
 An explicit model and variant selected in OpenCode remains authoritative for that
 session. Child role defaults fill absent native settings and may be overridden by

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.12.25-mission-continuity-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.1-quality-first-review-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.12.25-mission-continuity-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.1-quality-first-review-v1";

package/dist/core/initialize.d.ts

@@ -11,7 +11,7 @@ export declare class ProjectInitializationError extends Error {
     readonly code: ProjectInitializationErrorCode;
     constructor(code: ProjectInitializationErrorCode, message: string, options?: ErrorOptions);
 }
-export declare const V010_COORDINATOR_MODEL = "openai/gpt-6-sol#xhigh";
+export declare const V010_COORDINATOR_MODEL = "openai/gpt-6.1-sol#xhigh";
 /**
  * Report a user config that routes the v0.10 Coordinator away from its packaged model. Measured Luna
  * Coordinators repeated plans and review dispatches until timeout, so init surfaces it without editing it.

package/dist/core/initialize.js

@@ -133,10 +133,10 @@ function classifyVersionTransition(installedValue, currentValue, v010Restore = f
     // cross-minor migration; skipped lines still fail closed instead of bypassing migration steps.
     const adjacentPreOneLine = installed.major === 0 && current.major === 0 &&
         current.minor === installed.minor + 1;
-    // v0.11 used a different runtime. This explicit v010 asset migration restores
-    // the 0.10 line directly into 0.12 without selecting any v0.11 execution path.
+    // v0.11 used a different runtime. The v010 asset migration restores the 0.10
+    // preview into the 0.12/0.13 Mission line without selecting a v0.11 execution path.
     const restoredPreview = v010Restore && installed.major === 0 && installed.minor === 10 &&
-        current.major === 0 && current.minor === 12;
+        current.major === 0 && (current.minor === 12 || current.minor === 13);
     return sameLine || adjacentPreOneLine || restoredPreview ? "compatible-update" : "incompatible";
 }
 async function metadata(path) {
@@ -542,7 +542,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
         preservedLegacyPaths,
     };
 }
-export const V010_COORDINATOR_MODEL = "openai/gpt-6-sol#xhigh";
+export const V010_COORDINATOR_MODEL = "openai/gpt-6.1-sol#xhigh";
 /**
  * Report a user config that routes the v0.10 Coordinator away from its packaged model. Measured Luna
  * Coordinators repeated plans and review dispatches until timeout, so init surfaces it without editing it.

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

@@ -80,7 +80,8 @@ export interface MissionExecution {
         startedAt: string;
         completedAt?: string;
         exit?: number;
-        status?: "completed" | "error";
+        status?: "running" | "completed" | "error";
+        shellID?: string;
         outcome?: "not-started" | "execution-failed" | "executed";
         result?: Record<string, unknown>;
     }[];
@@ -141,15 +142,10 @@ export interface OperatorMission {
         child?: string;
         /** Completed, independent initial review for this mission, not merely an inherited child ID. */
         initialPrompt?: string;
-        /** Reviews on this mission that found only missing evidence; bounded by MISSION_EVIDENCE_GAP_REVIEW_LIMIT. */
+        /** Observed evidence-only reviews; reporting only, never an acceptance threshold. */
         evidenceGapReviews?: number;
     };
 }
-/**
- * Evidence-only findings do not establish a defect. Each extra round costs a full Reviewer pass and often a
- * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
- */
-export declare const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 export declare const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export declare function missionReviewScope(previous: MissionReviewScope | undefined, ...runs: OperatorState[]): MissionReviewScope;
@@ -217,5 +213,5 @@ export declare function missionPlan(mission: OperatorMission, raw: unknown): Ope
 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;
-/** Project explicitly grouped R-ID traces into the legacy reviewer's ordered criterion mapping. */
-export declare function missionReviewTraces(mission: OperatorMission, raw: unknown): string[];
+/** Optional implementation notes supplement host-observed source/checks; prose is not a coverage gate. */
+export declare function missionReviewTraces(_mission: OperatorMission, raw: unknown): string[];

package/dist/core/operator-mission.js

@@ -18,11 +18,6 @@ export function missionValidationCommand(command) {
     const expression = `exec(${JSON.stringify(heredoc[4])})`;
     return `${heredoc[1]} -c '${expression.replaceAll("'", "'\\''")}'`;
 }
-/**
- * Evidence-only findings do not establish a defect. Each extra round costs a full Reviewer pass and often a
- * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
- */
-export const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 export const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export function missionReviewScope(previous, ...runs) {
@@ -38,7 +33,7 @@ export function missionReviewVerdict(text) {
 /** Whether the recorded review permits submission and acceptance of the current candidate. */
 export function missionReviewAccepted(review) {
     return review.verdict === "PASS" || review.verdict === "skipped-low-risk" ||
-        (review.verdict === "evidence-gaps" && (review.evidenceGapReviews ?? 0) >= MISSION_EVIDENCE_GAP_REVIEW_LIMIT);
+        review.verdict === "evidence-gaps";
 }
 export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
@@ -241,11 +236,11 @@ export class OperatorMissionRuntime {
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
-            // Explicit replacement links the latest cancelled run even when a user narrows the
-            // request in the same turn. Ordinary same-turn continuation still retains acceptance.
-            // A cancelled standalone/legacy run has no mission-owned runID; only replacement links it.
-            const predecessor = previous?.runID ?? previous?.supersededRunID ??
-                (replaceRequirements ? options.cancelledRunID : undefined);
+            // The Operator runtime's current cancelled run is authoritative for an explicit
+            // replacement. A no-run mission can still carry an older ancestor's run ID.
+            // Ordinary continuation retains that predecessor when no current run is supplied.
+            const predecessor = (replaceRequirements ? options.cancelledRunID : undefined) ??
+                previous?.runID ?? previous?.supersededRunID;
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
                 kind: options.kind ?? "implementation",
                 context: (options.context ?? []).filter(item => item.id !== request.id),
@@ -469,7 +464,7 @@ export function missionPacket(mission, run) {
             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,
-            evidence_gap_review_limit: MISSION_EVIDENCE_GAP_REVIEW_LIMIT, accepted: reviewAccepted,
+            evidence_gaps_advisory: true, accepted: reviewAccepted,
             passed: currentReview && mission.review.verdict === "PASS", permits_submission: reviewAccepted && operationComplete } : null,
         ...(run ? { run_id: run.runID, status: run.phase, decision: run.decision,
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
@@ -482,21 +477,21 @@ export function missionPacket(mission, run) {
         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."
-                : 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" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted
-                            ? "Coordinator: the Reviewer found only missing evidence. Supply focused original-file excerpts through review_mission evidence and traces; do not re-implement. At the evidence-gap limit, review ends with the gaps listed, not with execution proof."
-                            : reviewAccepted
-                                ? "Coordinator: review permits submission. Submit the candidate with any remaining gaps; do not repeat passed validation or review. Operator performs final 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" ? (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." };
+                                : "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) {
@@ -506,19 +501,12 @@ export function missionReviewTask(mission) {
     return { ...review.task, prompt: `${MISSION_REVIEW_REFERENCE}${JSON.stringify({ r: mission.root,
             m: mission.id, n: review.runID, h: digest(review.task.prompt) })}` };
 }
-/** Project explicitly grouped R-ID traces into the legacy reviewer's ordered criterion mapping. */
-export function missionReviewTraces(mission, raw) {
-    if (!Array.isArray(raw) || raw.length === 0 || !raw.every(item => typeof item === "string" && item.trim())) {
-        throw new Error("mission-review-traces: supply concise implementation/test traces");
+/** Optional implementation notes supplement host-observed source/checks; prose is not a coverage gate. */
+export function missionReviewTraces(_mission, raw) {
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw) || !raw.every(item => typeof item === "string")) {
+        throw new Error("mission-review-traces: optional notes must be strings");
     }
-    const grouped = raw.map(text => ({ text,
-        ids: [...text.matchAll(/(?:^|[.;]\s+|[\r\n])\s*((?:R\d+\s*[/,]?\s*)+):/gu)]
-            .flatMap(match => match[1].match(/R\d+/gu) ?? []) }));
-    if (grouped.every(item => item.ids.length === 0) && raw.length === mission.requirements.length)
-        return raw;
-    const unknown = grouped.flatMap(item => item.ids).filter(id => !mission.requirements.some(requirement => requirement.id === id));
-    const missing = mission.requirements.filter(requirement => !grouped.some(item => item.ids.includes(requirement.id)));
-    if (unknown.length || missing.length)
-        throw new Error(`mission-review-traces: name the existing R IDs; missing ${missing.map(item => item.id).join(", ")}; unknown ${unknown.join(", ")}`);
-    return mission.requirements.map(requirement => grouped.filter(item => item.ids.includes(requirement.id)).map(item => item.text).join("\n"));
+    return raw.map(text => text.trim()).filter(Boolean);
 }

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

@@ -227,6 +227,22 @@ export interface OperatorState {
     decision: string | null;
     receipt: GoalTerminalReceipt | null;
 }
+export interface OperatorProgress {
+    readonly profile: string;
+    readonly view: "progress";
+    readonly run_id: string;
+    readonly stage: OperatorPhase;
+    readonly decision: string | null;
+    readonly current_unit: {
+        readonly id: string;
+        readonly title: string;
+        readonly status: UnitState["status"];
+    } | null;
+    readonly completed_units: number;
+    readonly total_units: number;
+    readonly budget_remaining_units: number | null;
+    readonly next_action: string | null;
+}
 /** A later mission may replace an unexecuted cancellation, but must retain settled work's acceptance. */
 export declare function cancelledMissionRetainsAcceptance(state: OperatorState): boolean;
 export declare function operatorGitPathAuthorized(path: string, scopes: readonly string[], platform?: NodeJS.Platform): boolean;
@@ -371,10 +387,13 @@ export declare class OperatorRuntime {
     draftStatus(root: string): Promise<unknown | undefined>;
     completionGoalFingerprint(state: OperatorState): Promise<string>;
     verifyContinuityControls(state: OperatorState): Promise<void>;
+    /** Compact, read-only projection of the same durable run and decision as the complete packet. */
+    progress(state: OperatorState, budgetRemainingUnits: number | null, nextAction?: string | null): OperatorProgress;
     packet(state: OperatorState): unknown;
     /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
     workerContext(root: string, child: string): Promise<string | undefined>;
     continuationCheckpoint(root: string): Promise<string | undefined>;
+    private continuationNextAction;
     private controlReference;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */

package/dist/core/operator-runtime.js

@@ -920,11 +920,11 @@ export class OperatorRuntime {
                 `goal_declaration_path: ${declarationPath}`, "acceptance:", ...plan.acceptance.map(value => `  - ${value}`),
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
                 ...(mission ? ["Read handoff_path and other repository files using their project-relative paths as supplied. The native working directory is project_root; do not prepend or reconstruct its absolute path for read/search/shell. Copy project_root only when binding the write gate. Preserve explicitly declared external paths."] : []),
-                mission ? "Read-only investigation commands are unrestricted. Use shell to reproduce and diagnose without asking for command registration. Keep all writes, including generated/transient outputs and cleanup, inside unit.write. Run formal validation exactly as listed, in order and in separate calls, so the host records its real result. If a write scope or formal check must change, return the precise change to your Coordinator; it can extend/redeclare immediately within the original requirements. Diagnostic success is not formal acceptance evidence."
+                mission ? "Read-only investigation commands are unrestricted. Use shell to reproduce and diagnose without asking for command registration. Keep all writes, including generated/transient outputs and cleanup, inside unit.write. Run formal validation exactly as listed, in order and in separate calls, so the host records its real result. If a write scope or formal check must change, return the precise change to your parent Operator or Coordinator; it can extend/redeclare immediately within the original requirements. Diagnostic success is not formal acceptance evidence."
                     : "Execute validation in its declared order. Earlier entries may be approved generator, build, formatter, or exact cleanup commands required before canonical criterion tests. Every persistent or transient generator output must be declared in unit.write. Cleanup may remove only declared unit.write outputs and must be an explicit ordered command after generation and before post-commit or canonical validation; never add an ignore rule or remove an undeclared path. If any necessary command, input, output, or cleanup is missing, do not run an undeclared command or variant and do not use resume evidence tooling to invent permission; return a contract-repair decision.",
                 ...(mission ? [] : ["Preserve existing public API success and error return semantics unless acceptance explicitly changes them, and cover those compatibility boundaries in the declared validation."]),
                 mission
-                    ? "Complete the assigned work and listed validation within this Task. For a known operation, proceed through setup, execution and result collection; preparation alone is not execution. Preserve existing public behavior when changing source. Do not spawn nested subagents. The Coordinator handles any applicable independent review after your return; review is not a prerequisite to execution. Return actual results, including failed or not-started operations, and any exact contract correction needed."
+                    ? "Complete the assigned work and listed validation within this Task. For a known operation, proceed through setup, execution and result collection; preparation alone is not execution. Preserve existing public behavior when changing source. Do not spawn nested subagents. The parent Operator or Coordinator handles any applicable independent review after your return; review is not a prerequisite to execution. Return actual results, including failed or not-started operations, and any exact contract correction needed."
                     : "Do not spawn nested subagents for consultation. Required consultations belong to the root before dispatch; use the confirmed decisions and evidence declared in the unit objective and inputs. If required consultation results or user decisions are missing, return the exact contract gap to the parent instead of attempting a deeper Task, inventing consent, or asking the user to repeat an already recorded decision.",
                 ...(plan.git_lifecycle !== undefined && index === plan.units.length - 1 ? [
                     `git_post_commit_validation: ${JSON.stringify(plan.git_lifecycle.post_commit_validation)}`,
@@ -1564,6 +1564,11 @@ export class OperatorRuntime {
                 state.units.some(candidate => candidate.terminalRescue))
                 throw new Error("operator-mission-normal-remediation-unavailable");
             await this.verifyControls(unit);
+            // The ordinary retry keeps its exact scope and validation, but the next Worker needs the
+            // host-observed failed command/exit rather than reconstructing it from an earlier session.
+            unit.task = { ...unit.task, prompt: `${unit.task.prompt}\nnormal_remediation_prior_validation: ${JSON.stringify({
+                    command: unit.failure.command, exit_code: unit.failure.exitCode
+                })}` };
             unit.normalRemediationUsed = true;
             unit.status = "pending";
             unit.callID = null;
@@ -1899,6 +1904,16 @@ export class OperatorRuntime {
         for (const unit of current.units)
             await this.verifyControls(unit);
     }
+    /** Compact, read-only projection of the same durable run and decision as the complete packet. */
+    progress(state, budgetRemainingUnits, nextAction) {
+        const current = state.units.find(unit => unit.status !== "succeeded");
+        const authoritativeAction = nextAction !== undefined ? nextAction
+            : this.continuationNextAction(state);
+        return { profile: state.profile, view: "progress", run_id: state.runID, stage: state.phase, decision: state.decision,
+            current_unit: current === undefined ? null : { id: current.unit.id, title: current.unit.title, status: current.status },
+            completed_units: state.units.filter(unit => unit.status === "succeeded").length, total_units: state.units.length,
+            budget_remaining_units: budgetRemainingUnits, next_action: typeof authoritativeAction === "string" ? authoritativeAction : null };
+    }
     packet(state) {
         const proved = new Set(state.units.flatMap(unit => unit.evidence.flatMap(item => item.measurement.criterion_ids)));
         const current = state.units.find(unit => unit.status !== "succeeded");
@@ -2030,9 +2045,10 @@ export class OperatorRuntime {
     }
     async continuationCheckpoint(root) {
         const state = await this.read(root);
-        const cancelledRemediation = state?.phase === "cancelled" &&
-            [ACCEPTANCE_REMEDIATION_DECISION, REVIEW_REMEDIATION_DECISION].includes(state.decision ?? "");
-        if (!state || state.phase === "completed" || (state.phase === "cancelled" && !cancelledRemediation))
+        if (!state)
+            return undefined;
+        const nextAction = this.continuationNextAction(state);
+        if (nextAction === null)
             return undefined;
         const current = state.units.find(unit => unit.status !== "succeeded");
         return JSON.stringify({ authority: "durable-operator-state", root_session_id: state.rootSessionID,
@@ -2041,14 +2057,21 @@ export class OperatorRuntime {
             next_task_ref: current?.status === "pending" ? (state.units.length > 1
                 ? state.operatorSessionID === null ? this.dispatchTask(state).prompt : null
                 : current.repairValidation === null ? this.workerTask(state, current).prompt : this.repairWorkerTask(state, current).prompt) : null,
-            next_action: state.decision === ACCEPTANCE_REMEDIATION_DECISION || state.decision === REVIEW_REMEDIATION_DECISION
-                ? `call ${this.profile.toolPrefix}operator_status and execute its cancel-then-replacement next_action in this turn; do not stop after reporting status or call resume_operator`
-                : state.phase === "awaiting-acceptance" ? `call ${this.profile.toolPrefix}operator_status and follow its independent-review next_action; do not complete before review disposition`
-                    : state.phase === "prepared" ? "call operator_status, then operator_next; dispatch only the exact returned Task"
-                        : state.phase === "running" ? "call operator_status; do not duplicate the running Task"
-                            : state.phase === "cancelled"
-                                ? `call ${this.profile.toolPrefix}operator_status and execute its prepare_operator next_action in this turn; do not stop after reporting status`
-                                : `call ${this.profile.toolPrefix}operator_status and execute its exact next_action in this turn; do not stop after reporting status` });
+            next_action: nextAction });
+    }
+    continuationNextAction(state) {
+        const cancelledRemediation = state.phase === "cancelled" &&
+            [ACCEPTANCE_REMEDIATION_DECISION, REVIEW_REMEDIATION_DECISION].includes(state.decision ?? "");
+        if (state.phase === "completed" || (state.phase === "cancelled" && !cancelledRemediation))
+            return null;
+        return state.decision === ACCEPTANCE_REMEDIATION_DECISION || state.decision === REVIEW_REMEDIATION_DECISION
+            ? `call ${this.profile.toolPrefix}operator_status and execute its cancel-then-replacement next_action in this turn; do not stop after reporting status or call resume_operator`
+            : state.phase === "awaiting-acceptance" ? `call ${this.profile.toolPrefix}operator_status and follow its independent-review next_action; do not complete before review disposition`
+                : state.phase === "prepared" ? "call operator_status, then operator_next; dispatch only the exact returned Task"
+                    : state.phase === "running" ? "call operator_status; do not duplicate the running Task"
+                        : state.phase === "cancelled"
+                            ? `call ${this.profile.toolPrefix}operator_status and execute its prepare_operator next_action in this turn; do not stop after reporting status`
+                            : `call ${this.profile.toolPrefix}operator_status and execute its exact next_action in this turn; do not stop after reporting status`;
     }
     controlReference(path) {
         const local = relative(this.projectRoot, path);

package/dist/plugin/adaptive-remediation-host.d.ts

@@ -23,7 +23,7 @@ export interface AdaptiveReviewProvider {
         readonly fingerprint: string;
     }>;
 }
-export declare const DEFAULT_ADAPTIVE_REMEDIATION_MODEL = "openai/gpt-6-sol";
+export declare const DEFAULT_ADAPTIVE_REMEDIATION_MODEL = "openai/gpt-6.1-sol";
 export interface AdaptiveRemediationSessionClient extends OpenCodeModelAvailabilityClient {
     session: {
         create(input: {

package/dist/plugin/adaptive-remediation-host.js

@@ -10,7 +10,7 @@ import { produceWorktreeCommitArtifact, runContainedValidation } from "../core/w
 import { openCodeModel } from "./model-routing-hook.js";
 const SHA = /^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u;
 const HASH = /^[a-f0-9]{64}$/u;
-export const DEFAULT_ADAPTIVE_REMEDIATION_MODEL = "openai/gpt-6-sol";
+export const DEFAULT_ADAPTIVE_REMEDIATION_MODEL = "openai/gpt-6.1-sol";
 const responseData = (value) => {
     if (value === null || typeof value !== "object")
         return {};

package/dist/plugin/index.js

@@ -6060,8 +6060,12 @@ export const SortieDogsPlugin = async (input, options) => {
                         appLogInfo("run-metrics.career-unavailable", textInput.sessionID, { outcome: runOutcome }, "warn");
                     }
                 }
-                if (sortieResult !== undefined)
-                    textOutput.text = insertSortieResult(textOutput.text, sortieResult);
+                if (sortieResult !== undefined) {
+                    const review = terminal?.receipt?.status === "succeeded"
+                        ? await input.runtimeBridge?.missionReviewPresentation?.(textInput.sessionID).catch(() => undefined)
+                        : undefined;
+                    textOutput.text = insertSortieResult(textOutput.text, sortieResult, review?.verdict, review?.evidenceGaps);
+                }
                 else if (metrics !== undefined && runOutcome === "DONE")
                     textOutput.text = insertRunMetrics(textOutput.text, metrics);
                 const { debrief: _debriefObservation, ...metricSummary } = metrics ?? {};
@@ -7445,7 +7449,7 @@ export const SortieDogsPlugin = async (input, options) => {
         },
     };
     input.runtimeBridge?.connected?.({
-        renderReturnReport: async (root, text, expectedReceipt) => {
+        renderReturnReport: async (root, text, expectedReceipt, missionReview, reviewEvidenceGaps) => {
             let rendered;
             await serializeChatTransition(root, async () => {
                 if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
@@ -7473,7 +7477,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 catch {
                     appLogInfo("run-metrics.career-unavailable", root, { profile: runtimeProfile.id }, "warn");
                 }
-                rendered = insertSortieResult(receiptBoundTerminalText(text, receipt), result);
+                rendered = insertSortieResult(receiptBoundTerminalText(text, receipt), result, missionReview, reviewEvidenceGaps);
             });
             return rendered;
         },

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

@@ -1,6 +1,17 @@
 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";
+/** Show native command outcomes to the Reviewer without turning non-criterion checks into acceptance evidence. */
+export declare function observedMissionValidation(validation: readonly string[], childSessionID: string | null, history: readonly Record<string, unknown>[]): {
+    attempts: readonly {
+        command: string;
+        exit_code: number | null;
+        started_ms: number | null;
+        completed_ms: number | null;
+    }[];
+    not_observed: readonly string[];
+    omitted_attempts: number;
+};
 export declare function missionReviewBaseline(directory: string): Promise<string | undefined>;
 /** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
 export declare function initialMissionReviewPrompt(mission: OperatorMission, prompts: readonly string[]): string | undefined;
@@ -14,4 +25,5 @@ export declare function missionReviewSource(directory: string, run: OperatorStat
     fingerprint: string;
     excerpt: string;
     truncatedEvidence: string[];
+    truncatedSource: string[];
 }>;