sortie-dogs 0.12.24 → 0.13.0

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.24-review-evidence-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.0-fast-first-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.24-review-evidence-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.0-fast-first-v1";

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) {

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

@@ -174,7 +174,7 @@ export declare class OperatorMissionRuntime {
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
     private load;
-    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     private loadMission;
     /** Find exactly one archived cancelled mission that owned this run; ambiguity never grants recovery. */
     archivedRun(root: string, runID: string): Promise<OperatorMission | undefined>;
@@ -217,5 +217,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. */
+/** Project grouped R-ID traces, including consecutive ranges, into the existing per-criterion mapping. */
 export declare function missionReviewTraces(mission: OperatorMission, raw: unknown): string[];

package/dist/core/operator-mission.js

@@ -113,10 +113,10 @@ export class OperatorMissionRuntime {
             throw error;
         }
     }
-    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     async loadMission(root) {
         const state = await this.load(this.file(root));
-        if (!state || state.supersededRunID !== undefined || state.runID !== null ||
+        if (!state || state.supersededRunID !== undefined || state.runID !== null || state.requirementsReplaced ||
             !["open", "running", "submitted", "cancelled"].includes(state.phase) || state.requests.length === 0)
             return state;
         const directory = join(this.projectRoot, this.profile.stateDirectory, "missions");
@@ -241,10 +241,11 @@ export class OperatorMissionRuntime {
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
-            // A cancelled standalone/legacy run has no mission-owned runID. Only an explicit
-            // replacement may link it; normal continuation must not silently inherit its goal.
-            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),
@@ -252,7 +253,7 @@ export class OperatorMissionRuntime {
                 ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
                 ...((previous === undefined || previous.phase === "cancelled") &&
-                    (previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
+                    (replaceRequirements || previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
                     ? { supersededRunID: predecessor } : {}) };
             await this.save(this.file(root), state);
             return state;
@@ -505,19 +506,35 @@ 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. */
+/** Project grouped R-ID traces, including consecutive ranges, into the existing per-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");
     }
     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) ?? []) }));
+        ids: [...text.matchAll(/(?:^|[.;]\s+|[\r\n])\s*((?:R\d+\s*[-/,]?\s*)+):/gu)]
+            .flatMap(match => [...match[1].matchAll(/R(\d+)(?:\s*-\s*R(\d+))?/gu)]
+            .flatMap(([, first, last]) => {
+            const firstID = `R${first}`;
+            if (last === undefined)
+                return [firstID];
+            const lastID = `R${last}`;
+            const start = mission.requirements.findIndex(item => item.id === firstID);
+            const end = mission.requirements.findIndex(item => item.id === lastID);
+            if (start < 0 || end < 0)
+                return [firstID, lastID];
+            if (start > end)
+                throw new Error(`mission-review-traces: descending range ${firstID}-${lastID}`);
+            return mission.requirements.slice(start, end + 1).map(item => item.id);
+        })) }));
     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(", ")}`);
+        throw new Error(`mission-review-traces: name the existing R IDs; ${[
+            ...(missing.length ? [`missing ${missing.map(item => item.id).join(", ")}`] : []),
+            ...(unknown.length ? [`unknown ${unknown.join(", ")}`] : []),
+        ].join("; ")}`);
     return mission.requirements.map(requirement => grouped.filter(item => item.ids.includes(requirement.id)).map(item => item.text).join("\n"));
 }

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;

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[];
 }>;

package/dist/plugin/mission-review.js

@@ -11,8 +11,36 @@ import { canonicalAgent } from "../core/runtime-profile.js";
 import { taskChildSessionID } from "./task-result-repair.js";
 import { normalizeManifestScope } from "../core/path.js";
 import { declaredArtifacts } from "./declared-artifacts.js";
+import { normalizeCommand } from "./gate.js";
 const exec = promisify(execFile);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Show native command outcomes to the Reviewer without turning non-criterion checks into acceptance evidence. */
+export function observedMissionValidation(validation, childSessionID, history) {
+    const declared = validation.map(normalizeCommand), expected = new Set(declared);
+    const time = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+    const attempts = childSessionID === null ? [] : history.flatMap(message => {
+        if (!record(message.info) || message.info.role !== "assistant" || message.info.sessionID !== childSessionID ||
+            !Array.isArray(message.parts))
+            return [];
+        return message.parts.flatMap(part => {
+            if (!record(part) || part.type !== "tool" || !["bash", "shell", "powershell", "pwsh"].includes(String(part.tool)) ||
+                !record(part.state) || part.state.status !== "completed" || !record(part.state.input) ||
+                typeof part.state.input.command !== "string")
+                return [];
+            const command = normalizeCommand(part.state.input.command);
+            if (!expected.has(command))
+                return [];
+            const exit = record(part.state.metadata) ? part.state.metadata.exit : undefined;
+            return [{ command, exit_code: typeof exit === "number" && Number.isSafeInteger(exit) ? exit : null,
+                    started_ms: record(part.time) ? time(part.time.ran) : null,
+                    completed_ms: record(part.time) ? time(part.time.completed) : null }];
+        });
+    });
+    // Retain early attempts and the latest checks if a Worker retried many times.
+    const shown = attempts.length > 32 ? [...attempts.slice(0, 8), ...attempts.slice(-24)] : attempts;
+    return { attempts: shown, not_observed: declared.filter(command => !attempts.some(item => item.command === command)),
+        omitted_attempts: attempts.length - shown.length };
+}
 /** Use the space left by short references for longer requested branches, without starving later references. */
 function focusedAllowances(sizes, budget) {
     const allowances = sizes.map(() => 0);
@@ -65,19 +93,22 @@ export function initialMissionReviewPrompt(mission, prompts) {
 }
 /** Recover from native completion records, never from the pending review's inherited child ID. */
 export async function completedMissionReviewPrompts(mission, profile, root, requestedPrompt, host) {
-    if (!mission || mission.root !== root || !mission.coordinator || ["completed", "cancelled"].includes(mission.phase) ||
+    if (!mission || mission.root !== root || ["completed", "cancelled"].includes(mission.phase) ||
         mission.review?.task?.prompt !== requestedPrompt)
         return [];
     // The completion hook has already bound this prompt to a real independent Reviewer child.
     // Avoid a second V2 history read when its page/list API is temporarily unavailable.
     if (initialMissionReviewPrompt(mission, []))
         return [mission.review.initialPrompt];
-    const coordinator = await host.get(mission.coordinator);
-    if (!record(coordinator) || coordinator.parentID !== root || canonicalAgent(profile, coordinator.agent) !== "dog-operator")
-        return [];
+    const owner = mission.coordinator ?? root;
+    if (mission.coordinator !== null) {
+        const coordinator = await host.get(owner);
+        if (!record(coordinator) || coordinator.parentID !== root || canonicalAgent(profile, coordinator.agent) !== "dog-operator")
+            return [];
+    }
     const prompts = [];
-    for (const message of (await host.messages(mission.coordinator)).slice(-1000)) {
-        if (!record(message.info) || message.info.role !== "assistant" || message.info.sessionID !== mission.coordinator ||
+    for (const message of (await host.messages(owner)).slice(-1000)) {
+        if (!record(message.info) || message.info.role !== "assistant" || message.info.sessionID !== owner ||
             !Array.isArray(message.parts))
             continue;
         for (const part of message.parts) {
@@ -89,7 +120,7 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
             if (!childID)
                 continue;
             const child = await host.get(childID);
-            if (!record(child) || child.parentID !== mission.coordinator || canonicalAgent(profile, child.agent) !== "dog-reviewer")
+            if (!record(child) || child.parentID !== owner || canonicalAgent(profile, child.agent) !== "dog-reviewer")
                 continue;
             let prompt = part.state.input.prompt;
             if (prompt.startsWith(MISSION_REVIEW_REFERENCE)) {
@@ -218,7 +249,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
     if (writes.length === 0)
         return { fingerprint: `sha256:${hash.digest("hex")}`,
             excerpt: selected + "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]",
-            truncatedEvidence };
+            truncatedEvidence, truncatedSource: [] };
     // The shared dependency environment is local tooling, never reviewed or pinned source.
     const external = [], local = [];
     for (const path of writes) {
@@ -280,7 +311,8 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
             const absolute = resolve(directory, path), stat = await lstat(absolute);
             hash.update(String(stat.mode));
             const include = untracked.has(path) || unchanged;
-            const room = include ? Math.max(0, 24_000 - Buffer.byteLength(excerpt)) : 0;
+            const heading = `\n--- ${untracked.has(path) ? "new file" : "current file"}: ${path} ---\n`;
+            const room = include ? Math.max(0, 24_000 - Buffer.byteLength(excerpt) - Buffer.byteLength(heading)) : 0;
             let preview = Buffer.alloc(0);
             if (stat.isSymbolicLink()) {
                 const content = Buffer.from(await readlink(absolute));
@@ -297,9 +329,27 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
                 }
             }
             if (include) {
-                if (room)
-                    excerpt += `\n--- ${untracked.has(path) ? "new file" : "current file"}: ${path} ---\n${preview.includes(0) ? "[binary artifact: bytes fingerprinted]" : preview.toString("utf8")}`;
-                if (stat.size > room)
+                const headingFits = Buffer.byteLength(excerpt) + Buffer.byteLength(heading) <= 24_000;
+                if (headingFits) {
+                    const rendered = preview.includes(0) ? "[binary artifact: bytes fingerprinted]" : preview.toString("utf8");
+                    let shown = rendered;
+                    if (Buffer.byteLength(rendered) > room) {
+                        let used = 0;
+                        const chars = [];
+                        for (const char of rendered) {
+                            const bytes = Buffer.byteLength(char);
+                            if (used + bytes > room)
+                                break;
+                            chars.push(char);
+                            used += bytes;
+                        }
+                        shown = chars.join("");
+                    }
+                    excerpt += heading + shown;
+                    if (stat.size > room || Buffer.byteLength(rendered) > room)
+                        omitted.push(path);
+                }
+                else
                     omitted.push(path);
             }
         }
@@ -321,8 +371,11 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         unreadable.push(...artifacts.unreadable);
     }
     const bytes = Buffer.from(excerpt);
+    const truncatedSource = [...new Set(omitted)];
+    if (bytes.length > 24_000 && truncatedSource.length === 0)
+        truncatedSource.push("(source diff exceeds excerpt budget)");
     return { fingerprint: `sha256:${hash.digest("hex")}`, excerpt: (bytes.length > 24_000 ? bytes.subarray(0, 24_000).toString("utf8") : excerpt) +
-            (bytes.length > 24_000 || omitted.length ? `\n[EXCERPT TRUNCATED: ${omitted.slice(0, 20).join(", ")}; supply focused traces for missing sections, not another implementation unit]` : "") +
+            (truncatedSource.length ? `\n[EXCERPT TRUNCATED: ${truncatedSource.slice(0, 20).join(", ")}; supply focused traces for missing sections, not another implementation unit]` : "") +
             (unreadable.length ? `\n[UNINSPECTED EXTERNAL DIRECTORIES: ${unreadable.slice(0, 20).join(", ")}; select specific result files as review evidence]` : ""),
-        truncatedEvidence };
+        truncatedEvidence, truncatedSource };
 }