sortie-dogs 0.12.15 → 0.12.16

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.15-review-lineage-model-gauges-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.16-operation-efficiency-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.15-review-lineage-model-gauges-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.16-operation-efficiency-v1";

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

@@ -8,11 +8,40 @@ export interface MissionRequest {
     id: string;
     text: string;
 }
+export interface MissionContext extends MissionRequest {
+    role: "user" | "assistant";
+}
+export interface MissionEvidenceExcerpt {
+    path: string;
+    offset: number;
+    limit: number;
+}
+export interface MissionExecution {
+    commands: string[];
+    directory: string;
+    observations: {
+        command: string;
+        directory: string;
+        callID: string;
+        sessionID: string;
+        startedAt: string;
+        completedAt?: string;
+        exit?: number;
+        status?: "completed" | "error";
+        outcome?: "not-started" | "execution-failed" | "executed";
+        result?: Record<string, unknown>;
+    }[];
+}
 export interface OperatorMission {
     version: "0.12";
     id: string;
     root: string;
     requests: MissionRequest[];
+    /** Prior public conversation context, not additional immutable requirements. */
+    context?: MissionContext[];
+    kind?: "implementation" | "operation";
+    /** Native shell observations of the requested operation, separate from auxiliary checks. */
+    execution?: MissionExecution;
     requirements: {
         id: string;
         text: string;
@@ -42,6 +71,7 @@ export interface OperatorMission {
         risk: string[];
         source: string;
         task: OperatorTask | null;
+        evidence?: MissionEvidenceExcerpt[];
         requestFingerprint?: string;
         verdict: "pending" | "PASS" | "findings" | "evidence-gaps" | "skipped-low-risk";
         result?: string;
@@ -61,6 +91,15 @@ export declare const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 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;
+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. */
+export declare function missionCommandOutcome(output: unknown, exit: unknown, status: unknown): {
+    outcome: "not-started" | "execution-failed" | "executed";
+    result?: Record<string, unknown>;
+};
+/** Bounded public text only: tool logs and private reasoning are not delegation context. */
+export declare function missionConversationContext(messages: readonly Record<string, unknown>[]): MissionContext[];
 /** Durable user intent and dispatch ownership. Execution/evidence still belong to the v0.10 engine. */
 export declare class OperatorMissionRuntime {
     readonly projectRoot: string;
@@ -78,7 +117,10 @@ export declare class OperatorMissionRuntime {
     read(root: string): Promise<OperatorMission | undefined>;
     required(root: string): Promise<OperatorMission>;
     capture(root: string, request: MissionRequest): Promise<void>;
-    start(root: string, requirements: unknown, replaceRequirements?: boolean): Promise<OperatorMission>;
+    start(root: string, requirements: unknown, replaceRequirements?: boolean, options?: {
+        kind?: OperatorMission["kind"];
+        context?: MissionContext[];
+    }): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     /** Keep host-accepted criteria ahead of new text, including an exactly linked settled predecessor. */
     carryForward(root: string, missionID: string, acceptance: readonly string[], supersededRunID?: string): Promise<OperatorMission>;

package/dist/core/operator-mission.js

@@ -32,6 +32,57 @@ 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);
 }
+export function missionExecutionStatus(mission) {
+    if (mission.kind !== "operation")
+        return "not-required";
+    const execution = mission.execution;
+    if (!execution || execution.observations.length === 0)
+        return "not-started";
+    const latest = execution.commands.map(command => [...execution.observations].reverse().find(item => item.command === command && item.directory === execution.directory));
+    if (latest.some(item => item && !item.completedAt))
+        return "running";
+    if (latest.some(item => item?.outcome === "execution-failed" || (item && (item.status === "error" || item.exit !== 0))))
+        return "execution-failed";
+    return latest.every(item => item?.outcome === "executed") ? "executed" : "not-started";
+}
+/** 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. */
+export function missionCommandOutcome(output, exit, status) {
+    const text = typeof output === "string" ? output.trim() : "";
+    let result;
+    for (const value of [text, ...text.split(/\r?\n/u).reverse().slice(0, 8)]) {
+        try {
+            const parsed = JSON.parse(value);
+            if (record(parsed)) {
+                result = parsed;
+                break;
+            }
+        }
+        catch { /* not a JSON summary */ }
+    }
+    const state = String(result?.status ?? "").toLowerCase().replaceAll("_", "-");
+    const summary = result ? Object.fromEntries(["status", "attempts", "launches", "inference_count", "reward", "score", "session_id", "exit"]
+        .filter(key => Object.hasOwn(result, key)).map(key => [key, result[key]])) : undefined;
+    const outcome = ["no-start", "not-started", "prepared", "preflight"].includes(state) || text === "NO_START" ||
+        [result?.attempts, result?.launches, result?.inference_count].some(value => value === 0) ? "not-started"
+        : status === "error" || exit !== 0 || ["execution-failed", "setup-failed", "route-failed"].includes(state)
+            ? "execution-failed" : "executed";
+    return { outcome, ...(summary ? { result: summary } : {}) };
+}
+/** Bounded public text only: tool logs and private reasoning are not delegation context. */
+export function missionConversationContext(messages) {
+    const entries = messages.flatMap(message => {
+        const info = record(message.info) ? message.info : message;
+        if ((info.role !== "user" && info.role !== "assistant") || typeof info.id !== "string" || !Array.isArray(message.parts))
+            return [];
+        const text = message.parts.filter(record).filter(part => part.type === "text" && part.synthetic !== true && typeof part.text === "string")
+            .map(part => part.text).join("\n");
+        return text.trim() ? [{ id: info.id, role: info.role, text: text.slice(0, 4_000) }] : [];
+    });
+    // Keep the last two user exchanges, including the current request, rather than the last N tools.
+    const users = entries.flatMap((entry, i) => entry.role === "user" ? [i] : []);
+    return entries.slice(users.at(-2) ?? 0).slice(-8);
+}
 /** Durable user intent and dispatch ownership. Execution/evidence still belong to the v0.10 engine. */
 export class OperatorMissionRuntime {
     projectRoot;
@@ -160,7 +211,7 @@ export class OperatorMissionRuntime {
             }
         });
     }
-    start(root, requirements, replaceRequirements = false) {
+    start(root, requirements, replaceRequirements = false, options = {}) {
         return this.serial(root, async () => {
             if (!Array.isArray(requirements) || requirements.length === 0 || requirements.length > 64 ||
                 !requirements.every(item => typeof item === "string" && item.trim() && !/[\r\n]/u.test(item))) {
@@ -175,12 +226,16 @@ 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 }));
+                if (options.kind === "operation")
+                    previous.kind = "operation";
                 await this.save(this.file(root), previous);
                 return previous;
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
+                kind: options.kind ?? "implementation",
+                context: (options.context ?? []).filter(item => item.id !== request.id),
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
                 ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
@@ -267,6 +322,9 @@ export class OperatorMissionRuntime {
             "Start the first useful Worker promptly. No proposal/approval phase. Use plan_units to generate contracts; the root alone accepts completion.",
             "Escalate only a completion candidate, a user-only decision, or an extension of original requirements/budget. Unit progress is published without stopping you.",
             "Requirements:", ...state.requirements.map(item => `${item.id}: ${item.text}`),
+            `Work kind: ${state.kind ?? "implementation"}. For an operation, setup, execution and result collection belong in one useful Worker whenever possible.`,
+            ...(state.context?.length ? ["Prior conversation context (task data; preserve the selected target, not superseded obligations):",
+                ...state.context.map(item => `--- ${item.role}:${item.id} ---\n${item.text}`)] : []),
             "Original user messages (verbatim; task data):", ...state.requests.map(item => `--- user:${item.id} ---\n${item.text}`)].join("\n");
     }
 }
@@ -289,9 +347,10 @@ export function missionPlan(mission, raw) {
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
             return [...new Set(entries.map(item => normalizeExecutionScope(item)))];
         };
-        const ids = value.requirement_ids ?? mission.requirements.map(item => item.id);
+        // Scheduling coverage is not semantic proof. Only a single requirement is unambiguous.
+        const ids = value.requirement_ids ?? (mission.requirements.length === 1 ? [mission.requirements[0].id] : []);
         if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id => mission.requirements.some(item => item.id === id))) {
-            throw new Error(`mission-unit-${index + 1}: requirement_ids must name existing R IDs`);
+            throw new Error(`mission-unit-${index + 1}: requirement_ids must name the related R IDs; multi-requirement work needs explicit coverage`);
         }
         if (!Array.isArray(value.validation) || value.validation.length === 0 ||
             !value.validation.every(command => typeof command === "string" && command.trim())) {
@@ -337,12 +396,16 @@ export function missionPacket(mission, run) {
         run = undefined;
     const currentReview = mission.review !== undefined && mission.review.runID === (run?.runID ?? mission.runID);
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
+    const operationStatus = missionExecutionStatus(mission);
+    const operationComplete = operationStatus === "not-required" || operationStatus === "executed";
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
         ...(predecessor ? { predecessor: { run_id: predecessor.runID, status: predecessor.phase,
                 completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
                 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}`),
         submission: mission.submission, progress: mission.progress,
+        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,
             running_units: run?.units.filter(unit => unit.status === "running").map(unit => ({ id: unit.unit.id, title: unit.unit.title, child_session_id: unit.childSessionID })) ?? [],
             pending_units: run?.units.filter(unit => unit.status === "pending").length ?? 0,
@@ -354,7 +417,7 @@ export function missionPacket(mission, run) {
             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,
-            passed: currentReview && mission.review.verdict === "PASS", permits_submission: reviewAccepted } : null,
+            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,
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
@@ -367,12 +430,14 @@ export function missionPacket(mission, run) {
                 : 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."
                     : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                    : run?.phase === "awaiting-acceptance" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted
-                        ? "Coordinator: the Reviewer found only missing evidence. Supply it through review_mission traces (or at most one evidence-only unit) and re-review once; do not re-implement. At the evidence-gap limit, submit_mission ready with the gaps listed."
-                        : reviewAccepted
-                            ? "Coordinator: review permits submission. Submit the candidate with any remaining gaps; do not repeat passed validation or review. Operator performs final acceptance."
-                            : "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." };
+                    : 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."
+                                : "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." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export function missionReviewTask(mission) {

package/dist/core/operator-runtime.js

@@ -915,9 +915,9 @@ export class OperatorRuntime {
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
                 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."
                     : "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.",
-                "Preserve existing public API success and error return semantics unless acceptance explicitly changes them, and cover those compatibility boundaries in the declared validation.",
+                ...(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
-                    ? "Do not spawn nested subagents for consultation. Required technical or user decisions that must precede implementation belong to the root before dispatch; use the confirmed decisions and evidence declared in the unit objective and inputs. If a required prior decision is missing, return the exact contract gap to the parent instead of implementing dependent changes, inventing consent, or asking the user to repeat an already recorded decision. Independent SourceReview is a separate post-implementation and post-validation review: do not require it before implementation or formal validation, and do not stop this Task solely because it has not yet occurred. Complete the assigned implementation and all listed formal validation commands, then return the real evidence so the Coordinator can dispatch the independent review_mission with applicable risk_tags (for example, public-logic). Do not conduct or delegate that independent review yourself. Reflect supplied prior Reviewer FINDINGS within this unit's scope."
+                    ? "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."
                     : "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)}`,

package/dist/plugin/fast-lane.js

@@ -28,6 +28,10 @@ function lineValue(prompt, key) {
     const values = [...prompt.matchAll(new RegExp(`^\\s*${escapedKey}\\s*:\\s*(.+?)\\s*$`, "gmu"))];
     return values.length === 1 ? values[0][1] : undefined;
 }
+/** Keep an unambiguous, known Strategy trigger when Japanese sentence punctuation joins its prose. */
+function normalizeAdvisorPrompt(prompt) {
+    return prompt.replace(/^([ \t]*strategy_trigger[ \t]*:[ \t]*(?:architecture-choice|cross-boundary-tradeoff|material-uncertainty))[。．][ \t]*(?=\S)/mu, "$1\n");
+}
 function hasReviewEvidence(prompt) {
     if (lineValue(prompt, "canonical_validation_exit") !== "0")
         return false;
@@ -416,13 +420,17 @@ export class FastLaneController {
             return;
         }
         if (role === "dog-advisor") {
-            const trigger = lineValue(prompt, "strategy_trigger");
+            const normalized = normalizeAdvisorPrompt(prompt);
+            const trigger = lineValue(normalized, "strategy_trigger");
             if (trigger === undefined || !STRATEGY_TRIGGER_SET.has(trigger)) {
                 const error = new FastLaneDeniedError("ADVISOR_TRIGGER_REQUIRED");
-                error.message += `; required: strategy_trigger: <${STRATEGY_TRIGGERS.join(" | ")}>; repair the request header, not runtime policy`;
+                error.message += `; required: strategy_trigger: <${STRATEGY_TRIGGERS.join(" | ")}> on its own line; ` +
+                    "correct this Task header and redispatch the same consultation before proceeding, not runtime policy";
                 throw error;
             }
-            const basis = fallbackBasis(prompt);
+            if (normalized !== prompt)
+                args.prompt = normalized;
+            const basis = fallbackBasis(normalized);
             const dispatches = state.advisorRequests.get(basis) ?? 0;
             const retry = lineValue(prompt, "fallback_retry");
             if ((dispatches === 0 && retry !== undefined) || (dispatches === 1 && retry !== "true")) {

package/dist/plugin/index.js

@@ -51,7 +51,7 @@ import { collectRunMetrics, createSortieResult, createGoalReport, insertRunMetri
 import { STABLE_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 import { evidenceFromObservedExecution } from "../core/observed-goal-evidence.js";
 import { receiptBoundTerminalText } from "./receipt-presentation.js";
-import { protectedSnapshot, refreshProtectedSnapshot } from "./protected-snapshot.js";
+import { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot } from "./protected-snapshot.js";
 import { settledUnitUsage } from "./unit-usage.js";
 import { goalCompletionReadiness } from "./goal-completion.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024, parallel: 512 * 1024 };
@@ -1477,10 +1477,15 @@ export const SortieDogsPlugin = async (input, options) => {
                 }
             }
         }
+        const mission = await new OperatorMissionRuntime(input.directory, runtimeProfile).read(root);
+        const operationInputs = mission?.kind === "operation" && mission.execution?.commands.includes(rawCommand) &&
+            resolve(input.directory, typeof args?.workdir === "string" ? args.workdir : ".") === mission.execution.directory
+            ? await operationInputSnapshot(authorization.projectRoot, snapshot.binding).catch(() => undefined) : undefined;
         hostGoalExecutions.set(toolInput.callID, { root, projectRoot: authorization.projectRoot,
             sessionID: toolInput.sessionID,
             callID: toolInput.callID, tool: toolInput.tool, command: [rawCommand], startedAt: new Date().toISOString(),
             binding: snapshot.binding, source: snapshot.source, candidate: snapshot.candidate,
+            ...(operationInputs === undefined ? {} : { operationInputs }),
             owner: validation?.request.owner ?? "worker", validation,
             ...(reusedEvidence === undefined ? {} : { reusedEvidence }) });
     }
@@ -1508,10 +1513,11 @@ export const SortieDogsPlugin = async (input, options) => {
             ? new Date(timing.start).toISOString() : execution.startedAt;
         const endedAt = typeof timing?.end === "number" && Number.isFinite(timing.end)
             ? new Date(timing.end).toISOString() : new Date().toISOString();
-        // The candidate is expected to change during a valid implementation task (the goal fixture
-        // itself is a declared write). Protect the source snapshot across the task, then bind evidence
-        // to the post-task candidate snapshot instead of rejecting the genuine mutation.
-        const fresh = refreshed !== undefined && refreshed.source === execution.source;
+        // Existing operations produce declared outputs. Preserve their read-only inputs during execution,
+        // then bind ordinary evidence to all post-operation bytes, including those outputs.
+        const fresh = refreshed !== undefined && (execution.operationInputs === undefined
+            ? refreshed.source === execution.source
+            : await operationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.operationInputs);
         const immutableRef = outcome === undefined || execution.reusedEvidence !== undefined ? undefined : goalFingerprint({ root: execution.root,
             child_session_id: execution.sessionID, call_id: execution.callID, command: execution.command,
             started_at: observedStartedAt, ended_at: endedAt, exit_code: exitCode ?? null, outcome,
@@ -4770,6 +4776,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 remedy: "No write-gate state changed after one retry; stop this candidate and record the local blocker.",
             },
         };
+        let conflicts = [];
         const deny = (reason, defects = []) => {
             const detail = remedies[reason] ?? {
                 recoverable: false,
@@ -4798,6 +4805,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 reason,
                 ...detail,
                 ...(reported.length === 0 ? {} : { defects: reported }),
+                ...(reason === "manifest-overlap" && conflicts.length ? { conflicts } : {}),
                 escalation,
             });
         };
@@ -4884,10 +4892,23 @@ export const SortieDogsPlugin = async (input, options) => {
             if (diagnostics.some(({ severity }) => severity === "error") ||
                 inspectionFingerprint(handoffValidation.value, diagnostics, validation.value) !== inspectedEntry.fingerprint)
                 return denyHandoffMismatch(handoffValue, contractDefects(diagnostics));
-            const conflictsWithActiveAuthorization = (writeScopes, readScopes) => [...sessionAuthorizations.entries()].some(([ownerSessionID, authorization]) => ownerSessionID !== sessionID && !authorization.suspended &&
-                (writeScopesOverlap(writeScopes, authorization.writeScopes) ||
-                    writeScopesOverlap(writeScopes, authorization.readScopes) ||
-                    writeScopesOverlap(readScopes, authorization.writeScopes)));
+            const conflictsWithActiveAuthorization = (writeScopes, readScopes) => {
+                conflicts = [];
+                for (const [ownerSessionID, authorization] of sessionAuthorizations) {
+                    if (ownerSessionID === sessionID || authorization.suspended)
+                        continue;
+                    for (const [requested, held, access] of [[writeScopes, authorization.writeScopes, "write/write"],
+                        [writeScopes, authorization.readScopes, "write/read"], [readScopes, authorization.writeScopes, "read/write"]]) {
+                        for (const left of requested)
+                            for (const right of held) {
+                                if (conflicts.length < 8 && writeScopesOverlap([left], [right])) {
+                                    conflicts.push({ session_id: ownerSessionID, requested: left, held: right, access });
+                                }
+                            }
+                    }
+                }
+                return conflicts.length > 0;
+            };
             const acquireDurableLease = async (readScopes, writeScopes) => {
                 if (activeSessions.get(sessionID)?.parallel !== "valid")
                     return undefined;
@@ -5103,7 +5124,7 @@ export const SortieDogsPlugin = async (input, options) => {
         for (const [sessionID, state] of activeSessions) {
             if (state.expiresAt > now)
                 continue;
-            if (state.inFlightCalls.size > 0)
+            if (state.inFlightCalls.size > 0 || childHasInFlightParentTask(sessionID))
                 state.expiresAt = now + ACTIVE_SESSION_CACHE.ttlMilliseconds;
             else
                 expireSession(sessionID);
@@ -5116,7 +5137,7 @@ export const SortieDogsPlugin = async (input, options) => {
         for (const [sessionID, state] of coordinatorRoots) {
             if (state.expiresAt > now)
                 continue;
-            const hasInFlightChild = [...sessionRoots.entries()].some(([childID, rootID]) => rootID === sessionID && (activeSessions.get(childID)?.inFlightCalls.size ?? 0) > 0);
+            const hasInFlightChild = [...sessionRoots.entries()].some(([childID, rootID]) => rootID === sessionID && ((activeSessions.get(childID)?.inFlightCalls.size ?? 0) > 0 || childHasInFlightParentTask(childID)));
             if (hasInFlightChild)
                 state.expiresAt = now + ACTIVE_SESSION_CACHE.ttlMilliseconds;
             else {
@@ -6565,6 +6586,8 @@ export const SortieDogsPlugin = async (input, options) => {
                     diagnosis.accepting = false;
                     diagnosisCalls.delete(toolInput.callID ?? "");
                 }
+                const returnedMissionWorker = completedChildSessionID !== undefined &&
+                    await input.runtimeBridge?.allowsInvestigativeShell?.(completedChildSessionID);
                 parallelCalls.delete(toolInput.callID ?? "");
                 activeSessions.get(toolInput.sessionID ?? "")?.inFlightCalls.delete(toolInput.callID ?? "");
                 if (coordinatorTaskFinished && diagnosis === undefined) {
@@ -6584,6 +6607,12 @@ export const SortieDogsPlugin = async (input, options) => {
                     evictSession(completedChildSessionID);
                     void childLifecycles.get(completedChildSessionID)?.check();
                 }
+                else if (completedChildSessionID !== undefined && activeSessions.get(completedChildSessionID)?.parallel !== "valid" &&
+                    returnedMissionWorker) {
+                    // Keep same-worker recovery identity, but a returned serial Task must not keep a live
+                    // write reservation. Rebinding the retained manifest reacquires it before any later write.
+                    await releaseWriteGate(completedChildSessionID);
+                }
             }
         },
         "tool.execute.before": async (toolInput, output) => {

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

@@ -1,5 +1,5 @@
 import type { OperatorState } from "../core/operator-runtime.js";
-import { type OperatorMission } from "../core/operator-mission.js";
+import { type MissionEvidenceExcerpt, type OperatorMission } from "../core/operator-mission.js";
 import { type RuntimeProfile } from "../core/runtime-profile.js";
 /** 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;
@@ -9,7 +9,7 @@ export declare function completedMissionReviewPrompts(mission: OperatorMission |
     messages(id: string): Promise<readonly Record<string, unknown>[]>;
 }): Promise<string[]>;
 /** Pin all scoped tracked/untracked source bytes, including deletions; display a bounded excerpt only. */
-export declare function missionReviewSource(directory: string, run: OperatorState): Promise<{
+export declare function missionReviewSource(directory: string, run: OperatorState, evidence?: readonly MissionEvidenceExcerpt[]): Promise<{
     fingerprint: string;
     excerpt: string;
 }>;

package/dist/plugin/mission-review.js

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { createReadStream } from "node:fs";
 import { lstat, readlink } from "node:fs/promises";
-import { isAbsolute, relative, resolve } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
+import { createInterface } from "node:readline";
 import { TOOL_ENVIRONMENT } from "../runtime-mission-assets.js";
 import { MISSION_REVIEW_REFERENCE } from "../core/operator-mission.js";
 import { canonicalAgent } from "../core/runtime-profile.js";
@@ -85,12 +86,38 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
     return prompts;
 }
 /** Pin all scoped tracked/untracked source bytes, including deletions; display a bounded excerpt only. */
-export async function missionReviewSource(directory, run) {
+export async function missionReviewSource(directory, run, evidence = []) {
     const hash = createHash("sha256").update(JSON.stringify(run.units.map(unit => ({ unit: unit.unit, hashes: unit.hashes }))));
+    let selected = "";
+    for (const entry of evidence) {
+        const absolute = resolve(directory, entry.path);
+        const allowed = run.units.flatMap(unit => [...unit.unit.read, ...unit.unit.write]).some(scope => {
+            const root = resolve(directory, scope === "." ? scope : normalizeManifestScope(scope).path), rest = relative(root, absolute);
+            return rest === "" || (rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest));
+        });
+        if (!allowed || !Number.isSafeInteger(entry.offset) || entry.offset < 1 ||
+            !Number.isSafeInteger(entry.limit) || entry.limit < 1 || entry.limit > 200)
+            throw new Error("mission-review-evidence: select up to 200 lines from a declared input/output");
+        const info = await lstat(absolute);
+        if (!info.isFile())
+            throw new Error("mission-review-evidence: select a regular file");
+        hash.update(JSON.stringify(entry)).update(String(info.size));
+        const stream = createReadStream(absolute);
+        stream.on("data", chunk => hash.update(chunk));
+        const lines = createInterface({ input: stream, crlfDelay: Infinity });
+        selected += `\n--- evidence: ${entry.path}:${entry.offset} ---\n`;
+        let number = 0;
+        for await (const line of lines) {
+            number++;
+            if (number >= entry.offset && number < entry.offset + entry.limit && Buffer.byteLength(selected) < 12_000) {
+                selected += `${number}: ${line.slice(0, 2_000)}\n`;
+            }
+        }
+    }
     const writes = [...new Set(run.units.flatMap(unit => unit.unit.write).map(path => path === "." ? path : normalizeManifestScope(path).path))];
     if (writes.length === 0)
         return { fingerprint: `sha256:${hash.digest("hex")}`,
-            excerpt: "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]" };
+            excerpt: selected + "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]" };
     // The shared dependency environment is local tooling, never reviewed or pinned source.
     const external = [], local = [];
     for (const path of writes) {
@@ -109,8 +136,9 @@ export async function missionReviewSource(directory, run) {
     const ignored = local.length ? await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...scopes]) : "";
     for (const path of ignored.split("\0").filter(Boolean))
         untracked.add(path);
-    let excerpt = local.length ? await git(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--", ...scopes]).catch(() => git(["diff", "--no-ext-diff", "--no-textconv", "--", ...scopes])) : "";
-    const unchanged = excerpt.length === 0;
+    const diff = local.length ? await git(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--", ...scopes]).catch(() => git(["diff", "--no-ext-diff", "--no-textconv", "--", ...scopes])) : "";
+    const unchanged = diff.length === 0;
+    let excerpt = selected + diff;
     const paths = [...new Set([...names.split("\0"), ...ignored.split("\0")].filter(Boolean))].sort();
     const omitted = [];
     for (const path of paths) {

package/dist/plugin/profiled.js

@@ -12,7 +12,7 @@ import { decoratePreviewHeadings, returnReportPanel } from "./receipt-presentati
 import { sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
 import { normalizeCommand } from "./gate.js";
 import { normalizeRelativePath } from "../core/path.js";
-import { MISSION_EVIDENCE_GAP_REVIEW_LIMIT, OperatorMissionRuntime, missionPacket, missionPlan, missionReviewAccepted, missionReviewTask, missionReviewTraces, missionReviewVerdict } from "../core/operator-mission.js";
+import { MISSION_EVIDENCE_GAP_REVIEW_LIMIT, OperatorMissionRuntime, missionPacket, missionPlan, missionReviewAccepted, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionStatus, missionValidationCommand, missionReviewTraces, missionReviewVerdict } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionReviewSource } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
@@ -988,6 +988,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await requireRoot(context.sessionID);
                 const state = await operators.required(context.sessionID);
                 const mission = await missions.read(context.sessionID);
+                if (mission?.kind === "operation" && missionExecutionStatus(mission) !== "executed")
+                    return JSON.stringify({
+                        status: "not-ready", operation_status: missionExecutionStatus(mission),
+                        next_action: "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
+                        packet: missionPacket(mission, state)
+                    });
                 if (mission && !["completed", "cancelled"].includes(mission.phase))
                     await assertMissionReview(context.sessionID, mission);
                 if (args.run_id !== state.runID || args.acceptance_fingerprint !== state.acceptanceFingerprint)
@@ -1005,7 +1011,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     await operators.terminal(context.sessionID, result.receipt);
                 let panel;
                 if (input.returnReportTransport === "tool-result" && result.receipt?.status === "succeeded") {
-                    const text = `✅ **DONE** \`${state.runID}\` — ${state.acceptance.length} acceptance requirements verified.\n\n` +
+                    const text = `✅ **DONE** \`${state.runID}\` — declared checks passed; Operator accepted the result.\n\n` +
                         `**変更点:** ${state.units.map(unit => unit.unit.title).join("; ")}\n\n` +
                         `**確認結果:** 宣言検証合格 — ${[...new Set(state.units.flatMap(unit => unit.unit.validation))].join("; ")}` +
                         (mission?.review ? `\n独立レビュー: ${mission.review.verdict === "evidence-gaps" ? "証拠不足を残して受入れ（レビューPASSではない）" : mission.review.verdict}.` : "") + "\n\n**次:** なし";
@@ -1303,6 +1309,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         const stringList = { type: "array", items: { type: "string" } };
         tools[startMission] = { description: "Operator: save the current user requirements. Use intent=replace when the user changes an existing request (version, parallelism, target): host cancels the previous run and archives its requirements/results while retaining spend. Supply the complete current requirements, retaining constraints the user has not changed. For separate work in a different location use intent=new. Dispatch the Coordinator immediately, or plan_units for a known single-unit procedure; item count and runtime alone do not require a Coordinator.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
+                kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
                 intent: { type: "string", enum: ["", "continue", "new", "replace"], "x-sortie-optional": true } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
                 if (args.intent !== undefined && !["", "continue", "new", "replace"].includes(args.intent))
@@ -1317,16 +1324,34 @@ export function createProfiledPlugin(profile, assetVersion) {
                         if (relocated)
                             return JSON.stringify({ ...relocated, budget: await control.currentBudget(context.sessionID) });
                     }
-                    const mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements, args.intent === "replace" || args.intent === "new"));
+                    const mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements, args.intent === "replace" || args.intent === "new", {
+                        kind: args.kind === "operation" ? "operation" : "implementation",
+                        context: missionConversationContext(await messages(context.sessionID)),
+                    }));
                     return JSON.stringify({ ...locationObservation(context.sessionID), ...(mission.dispatchOpen
                             ? missionDispatchPacket(mission, await operators.read(context.sessionID))
                             : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
                                 next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." }) });
                 });
             } };
-        async function declareMissionUnits(root, actor, mission, raw, reason) {
+        async function declareMissionUnits(root, actor, mission, raw, reason, execution) {
             const previous = await operators.read(root);
             mission = await retainCancelledMissionAcceptance(root, mission, previous);
+            let operation = mission.execution;
+            // Models can serialize an optional operation field as an empty object for a normal edit.
+            // Do not turn an implementation mission into an operation (or block its first Worker).
+            const emptyImplementationExecution = mission.kind === "implementation" && record(execution) &&
+                Array.isArray(execution.commands) && execution.commands.length === 0;
+            if (execution !== undefined && !emptyImplementationExecution) {
+                if (!record(execution) || typeof execution.directory !== "string" || !execution.directory.trim() ||
+                    !Array.isArray(execution.commands) || execution.commands.length === 0 || execution.commands.length > 16 ||
+                    !execution.commands.every(command => typeof command === "string" && command.trim()))
+                    throw new Error("mission-operation-input: supply the actual operation commands and their working directory");
+                const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
+                const directory = resolve(input.directory, execution.directory);
+                // A corrected command is allowed on replan; retain prior observations for accounting.
+                operation = { commands, directory, observations: operation?.observations ?? [] };
+            }
             const plan = missionPlan(mission, raw);
             if (actor === root && (mission.coordinator !== null || plan.units.length !== 1))
                 throw new Error("mission-coordinator-required: dispatch the returned Coordinator task");
@@ -1376,6 +1401,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 item.phase = "running";
                 item.submission = null;
                 delete item.supersededRunID;
+                if (operation) {
+                    item.kind = "operation";
+                    item.execution = operation;
+                }
             });
             return JSON.stringify(await operators.next(root, actor));
         }
@@ -1384,9 +1413,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                         properties: { title: { type: "string" }, objective: { type: "string" },
                             read: { ...stringList, description: "Inputs that affect validation, not an allowlist for observation. Do not include whole live session/database/log trees just to inspect them." }, write: stringList,
                             validation: stringList, requirement_ids: stringList }, required: ["title", "objective", "write", "validation"] } },
+                execution: { type: "object", properties: { commands: stringList, directory: { type: "string" } },
+                    required: ["commands", "directory"], additionalProperties: false,
+                    description: "For an operation: the actual run/grade commands, not a preflight or NO_START check. Host observes their native shell completion; no handwritten proof file is needed.", "x-sortie-optional": true },
                 reason: { type: "string", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
-                return serializeDispatchTransition(root, () => declareMissionUnits(root, context.sessionID, mission, args.units, args.reason));
+                return serializeDispatchTransition(root, () => declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution));
             } };
         tools[expandUnit] = { description: "Coordinator: extend the stopped unit's write scope immediately within the original request. Keeps original requirements and cumulative budget; generates a replacement Worker contract. No Operator approval or handwritten manifest repair is needed. Use only after the Worker has returned.",
             args: { unit_id: stringSchema, paths: stringList, reason: stringSchema }, execute: async (args, context) => {
@@ -1405,6 +1437,9 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         tools[reviewMission] = { description: "Coordinator: prepare the independent Reviewer task from current source, requirements and observed checks. Supply risk_tags (empty only for genuinely low risk) and concise criterion-level changed-code/test traces. Host supplies diff, IDs, manifest, mappings and evidence; keep candidate lineage across corrections. A low-risk skip is recorded, never inferred from a missing review.",
             args: { risk_tags: { type: "array", items: { type: "string", enum: SOURCE_REVIEW_RISK_TAGS } },
+                evidence: { type: "array", maxItems: 6, items: { type: "object", additionalProperties: false,
+                        properties: { path: { type: "string" }, offset: { type: "integer", minimum: 1 }, limit: { type: "integer", minimum: 1, maximum: 200 } },
+                        required: ["path", "offset", "limit"] }, description: "Focused excerpts from existing declared inputs/outputs. Use for missing review evidence instead of creating another evidence-copying Worker.", "x-sortie-optional": true },
                 traces: stringList }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 const run = await operators.required(root);
@@ -1415,7 +1450,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!Array.isArray(risk) || !risk.every(tag => SOURCE_REVIEW_RISK_TAGS.includes(tag))) {
                     throw new Error("mission-review-input: use recognized risk tags");
                 }
-                const source = await missionReviewSource(input.directory, run);
+                const evidence = args.evidence;
+                if (evidence !== undefined && (!Array.isArray(evidence) || evidence.length > 6))
+                    throw new Error("mission-review-evidence: select at most six focused excerpts");
+                const source = await missionReviewSource(input.directory, run, evidence);
                 const requestFingerprint = goalFingerprint({ run: run.runID, source: source.fingerprint, risk, traces });
                 if (mission.review?.requestFingerprint === requestFingerprint && mission.review.verdict !== "pending") {
                     return JSON.stringify({ ...missionPacket(mission, run), status: "review-recorded",
@@ -1437,7 +1475,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     description: `🔎 ${run.units[0].unit.title}`, prompt: [
                         `candidate_id: ${mission.id}`, `review_phase: ${phase}`, "canonical_validation_exit: 0", `risk_tags: [${risk.join(", ")}]`,
                         "Review this candidate independently. Use the language of the requirements/traces. Invoke no tools. First line: exactly PASS, FINDINGS or EVIDENCE_GAPS.",
-                        "Use EVIDENCE_GAPS only when no finding establishes a source/test defect and every finding is proof the supplied artifact cannot settle, including process history later established on the base. Any concrete defect uses FINDINGS.",
+                        "Use EVIDENCE_GAPS only when no concrete source/test defect is established and a specific acceptance-relevant behavior or required validation cannot be settled by the supplied artifact. Name the affected path and why the missing evidence matters; do not request a generic route inventory or raw history for incidental workflow constraints already covered by a concise Worker trace. Any concrete defect uses FINDINGS.",
                         "This Reviewer's native outcome and final acceptance can only be observed after this review. List those as deferred Operator checks, not as a reason to request another review. Still assess all available source, validation and historical evidence independently.",
                         `acceptance: ${JSON.stringify(run.acceptance)}`, `changedLogicSummary: ${JSON.stringify(traces)}`,
                         ...run.acceptance.map((_, i) => `acceptance[${i}] -> changedLogicSummary[${i}]`),
@@ -1447,7 +1485,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     ].join("\n") };
                 const reviewed = await missions.update(root, item => {
                     item.review = { runID: run.runID, risk: risk, source: source.fingerprint, requestFingerprint,
-                        task, verdict: task ? "pending" : "skipped-low-risk", ...(mission.review?.child ? { child: mission.review.child } : {}),
+                        task, evidence, verdict: task ? "pending" : "skipped-low-risk", ...(mission.review?.child ? { child: mission.review.child } : {}),
                         ...(initialPrompt ? { initialPrompt } : {}),
                         ...(mission.review?.evidenceGapReviews ? { evidenceGapReviews: mission.review.evidenceGapReviews } : {}) };
                 });
@@ -1456,13 +1494,17 @@ export function createProfiledPlugin(profile, assetVersion) {
         async function assertMissionReview(root, mission) {
             const run = await operators.required(root), review = mission.review;
             if (!review || review.runID !== run.runID || !missionReviewAccepted(review) ||
-                review.source !== (await missionReviewSource(input.directory, run)).fingerprint)
+                review.source !== (await missionReviewSource(input.directory, run, review.evidence)).fingerprint)
                 throw new Error("mission-review-required-or-stale");
         }
         tools[submitMission] = { description: "Coordinator: return only a completion candidate, a user-only decision, or a proven external/scope/budget blocker. Continue ordinary investigation, scope extensions and corrections yourself. Unit progress is published automatically without waking Operator.",
             args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 if (args.status === "ready") {
+                    if (mission.kind === "operation" && missionExecutionStatus(mission) !== "executed") {
+                        return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), status: "operation-incomplete",
+                            next_action: "Continue the requested operation or submit its actual blocker. A successful setup/NO_START check does not authorize ready." });
+                    }
                     const run = await operators.required(root);
                     if (run.phase !== "awaiting-acceptance")
                         throw new Error("mission-units-incomplete");
@@ -1957,6 +1999,17 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     else
                         Object.assign(output, outward);
+                    if (who.role === "dog-worker" && ["bash", "shell"].includes(request.tool) && mission?.execution &&
+                        typeof args.command === "string" && mission.execution.commands.includes(normalizeCommand(args.command)) &&
+                        resolve(input.directory, typeof args.workdir === "string" ? args.workdir : ".") === mission.execution.directory) {
+                        const command = normalizeCommand(args.command);
+                        await missions.update(root, item => {
+                            if (!item.execution.observations.some(observation => observation.callID === request.callID)) {
+                                item.execution.observations.push({ command, directory: item.execution.directory,
+                                    callID: request.callID, sessionID: request.sessionID, startedAt: new Date().toISOString() });
+                            }
+                        });
+                    }
                 }
                 catch (error) {
                     if (delegated) {
@@ -2005,8 +2058,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                         if (reviewed.review?.verdict === "evidence-gaps" && typeof output.output === "string") {
                             const count = reviewed.review.evidenceGapReviews ?? 0;
                             output.output += missionReviewAccepted(reviewed.review)
-                                ? `\n\nHOST: evidence-gap review ${count}/${MISSION_EVIDENCE_GAP_REVIEW_LIMIT} reached the limit. No defect was found; submit_mission ready is permitted. List the remaining evidence gaps in the summary.`
-                                : `\n\nHOST: evidence-gap review ${count}/${MISSION_EVIDENCE_GAP_REVIEW_LIMIT}. No defect was found; supply the requested evidence through review_mission traces (or at most one evidence-only unit) and re-review. Do not re-implement.`;
+                                ? `\n\nHOST: evidence-gap review ${count}/${MISSION_EVIDENCE_GAP_REVIEW_LIMIT} reached the limit. Review is closed with gaps; this does not prove execution or requirement completion. Submit ready only when the requested result is complete, and list the gaps.`
+                                : `\n\nHOST: evidence-gap review ${count}/${MISSION_EVIDENCE_GAP_REVIEW_LIMIT}. Supply focused original-file excerpts through review_mission evidence and traces. Do not create an evidence-copying Worker or re-implement.`;
                         }
                     }
                     taskOwners.delete(request.callID);
@@ -2034,6 +2087,21 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await core["tool.execute.after"]?.({ ...translate(request, false),
                     ...(ownership ? { sessionID: ownership.root } : {}) }, mapped);
                 Object.assign(output, translate(mapped, true));
+                if (!ownership && ["bash", "shell"].includes(request.tool.toLowerCase())) {
+                    const root = await rootFor(id);
+                    const mission = root ? await missions.read(root) : undefined;
+                    if (root && mission?.execution?.observations.some(item => item.callID === request.callID && item.sessionID === id)) {
+                        const metadata = record(output.metadata) ? output.metadata : {};
+                        await missions.update(root, item => {
+                            const observation = item.execution.observations.find(value => value.callID === request.callID && value.sessionID === id);
+                            observation.completedAt = new Date().toISOString();
+                            observation.status = output.status === "error" || metadata.status === "error" ? "error" : "completed";
+                            if (Number.isSafeInteger(metadata.exit))
+                                observation.exit = metadata.exit;
+                            Object.assign(observation, missionCommandOutcome(returnedOutput, metadata.exit, observation.status));
+                        });
+                    }
+                }
                 if (repairAccess !== null && ["bash", "shell"].includes(request.tool.toLowerCase())) {
                     const metadata = record(output.metadata) ? output.metadata : undefined;
                     const exit = metadata?.exit;

package/dist/plugin/protected-snapshot.d.ts

@@ -2,6 +2,9 @@ import { type GoalEvidence } from "../core/goal-bound.js";
 type Binding = NonNullable<GoalEvidence["protected_binding"]>;
 /** Live orchestration/Git bookkeeping is readable context, not the source being validated. */
 export declare function isRuntimeControlPath(path: string): boolean;
+/** An existing operation may create its declared outputs. Compare its other inputs during execution;
+ * ordinary evidence still pins the full post-operation source and outputs for later acceptance. */
+export declare function operationInputSnapshot(projectRoot: string, binding: Binding): Promise<string | undefined>;
 export declare function protectedSnapshot(authorization: {
     manifestPath: string;
     manifestHash: string;

package/dist/plugin/protected-snapshot.js

@@ -11,10 +11,12 @@ export function isRuntimeControlPath(path) {
     const first = path.replaceAll("\\", "/").split("/")[0];
     return controlRoots.has(process.platform === "win32" ? first.toLowerCase() : first);
 }
-async function protectedScopeDigest(projectRoot, paths, manifestHash, sourcePolicy) {
+async function protectedScopeDigest(projectRoot, paths, manifestHash, sourcePolicy, excluded = []) {
     const entries = [];
     const canonicalRoot = await realpath(projectRoot);
     const visit = async (absolute) => {
+        if (excluded.some(root => !outside(root, absolute)))
+            return true;
         const scoped = relative(projectRoot, absolute).replaceAll("\\", "/");
         if (scoped === ".." || scoped.startsWith("../") || isAbsolute(scoped))
             return false;
@@ -62,14 +64,27 @@ function outside(projectRoot, path) {
     const scoped = relative(projectRoot, path).replaceAll("\\", "/");
     return scoped === ".." || scoped.startsWith("../") || isAbsolute(scoped);
 }
-async function declaredScopeDigest(projectRoot, paths, manifestHash, source) {
+async function declaredScopeDigest(projectRoot, paths, manifestHash, source, excluded = []) {
     const local = paths.filter(path => !outside(projectRoot, path));
     const external = paths.filter(path => outside(projectRoot, path));
-    const project = await protectedScopeDigest(projectRoot, local, manifestHash, source ? "project-files-v1" : undefined);
+    const project = await protectedScopeDigest(projectRoot, local, manifestHash, source ? "project-files-v1" : undefined, excluded);
     if (project === undefined)
         return undefined;
     const artifacts = await declaredArtifacts(external).catch(() => undefined);
-    return artifacts && goalFingerprint({ project, external: artifacts.entries });
+    return artifacts && goalFingerprint({ project, external: artifacts.entries.filter(([path]) => !excluded.some(root => !outside(root, path))) });
+}
+/** An existing operation may create its declared outputs. Compare its other inputs during execution;
+ * ordinary evidence still pins the full post-operation source and outputs for later acceptance. */
+export async function operationInputSnapshot(projectRoot, binding) {
+    const manifest = await readFile(resolve(projectRoot, binding.manifest_path)).catch(() => undefined);
+    if (!manifest || `sha256:${createHash("sha256").update(manifest).digest("hex")}` !== binding.manifest_hash)
+        return undefined;
+    const paths = binding.source_paths.map(path => resolve(projectRoot, path));
+    const outputs = binding.candidate_paths.map(path => resolve(projectRoot, path));
+    const hash = binding.manifest_hash.slice("sha256:".length);
+    return binding.source_policy === "declared-paths-v1"
+        ? await declaredScopeDigest(projectRoot, paths, hash, true, outputs)
+        : await protectedScopeDigest(projectRoot, paths, hash, binding.source_policy, outputs);
 }
 export async function protectedSnapshot(authorization) {
     const manifestSource = await readFile(authorization.manifestPath).catch(() => undefined);

package/dist/runtime-assets-v010.js

@@ -393,59 +393,44 @@ same child, intent, read evidence and remaining budgets; continue investigation/
 Only in the execution phase, call next to read authoritative queue state and its current short Task reference rather than
 reconstructing criteria from a summary. Never use a standalone/generic worker as a fallback.
 `;
-/**
- * A constraint added to an existing construct is only complete when every existing form that reaches
- * that construct is intercepted or explicitly excluded. Partial interception passes a narrow suite and
- * still changes public behavior, so both the implementer and the reviewer require the same enumeration.
- * Syntax forms alone do not cover it: the same form can reach the rule through a different value
- * representation, and a case run with the rule inactive only reproduces the pre-existing behavior.
- */
-const EXISTING_SURFACE_COVERAGE_WORKER = `
-## Existing-surface coverage
-
-When the unit adds or tightens a rule on a construct the target already supports, enumerate the existing
-forms that create, bind, or mutate that construct before editing: single and multi-value forms, nested and
-composite values, every scope, and generated or implicit paths. Derive that list from the target's own
-grammar, node kinds, or dispatch tables, not from the request wording, and enumerate creation and binding
-routes separately from mutation routes; a request that names one route never proves the other is absent.
-Enumerate the value representations that reach the new rule as well: a value taken from a container element,
-field, or dynamic holder arrives through a different representation than a directly produced value, so it is a
-distinct entry even when its syntax form is already listed. Intercept each enumerated form or state why it
-stays out of scope, and exercise each intercepted form in the declared validation with the new rule active;
-a case that exercises the form while the new rule is inactive proves only the pre-existing behavior. Return
-the enumeration and its derivation source with the unit evidence. An enumerated form without a trace or a
-stated exclusion is an open defect, not a completed unit.
-
-Treat independently selected syntax or dispatch dimensions as combinations, not as interchangeable labels.
-For example, cardinality, optional-clause presence, scope, and value representation can select different
-branches even when each dimension works in one other case. Exercise the material combinations needed to cover
-those branches, and for a multi-target route prove the rule and result for every target rather than only the
-first target. A trace for one combination or one target does not cover the others.
+/** Keep coverage tied to actual changed branches, not a generic inventory of the whole API. */
+const CHANGED_PATH_COVERAGE_WORKER = `
+## Changed-path coverage
+
+When a fix changes a rule on an existing construct, inspect the affected source branches and the public
+entry path in the request. Check other routes or value representations only when the changed code, an
+existing test, or acceptance shows that they can reach a materially different branch or result. Exercise
+the reported case with the new rule active and the relevant adjacent behavior; add targeted cases for
+independent branches or multiple affected targets. A passing case with the new rule inactive does not
+prove the fix. Explain any material branch left unverified in the unit evidence.
+
+Do not turn this into an exhaustive inventory of creation, binding, mutation, syntax forms, value
+representations, or their Cartesian product. Do not add tests or scope for hypothetical routes without
+a source-backed reason that they affect the requested behavior.
 `;
-const EXISTING_SURFACE_COVERAGE_REVIEWER = `
-## Existing-surface coverage
-
-When an acceptance item constrains a construct the target already supports, require the artifact to enumerate
-the existing forms that create, bind, or mutate it and to trace each form to a result or a stated exclusion.
-Require the enumeration to name the target artifact it was derived from and to list creation and binding
-routes separately from mutation routes; an enumeration justified only by the request wording, or one that
-covers mutation routes while leaving creation routes unlisted, is incomplete. Require the value representations
-that reach the rule to be listed too, and require each trace to exercise the form with the new rule active; a
-trace whose case leaves the new rule inactive evidences only the pre-existing behavior. A missing enumeration, an
-excluded form without a reason, or an enumerated form without a trace is never PASS. When the supplied
-excerpts cannot settle the form and no defect is established, it is an evidence gap, not a FINDINGS defect.
-
-Reject a matrix that lists independent syntax or dispatch dimensions but traces them only in isolation. Require
-the material combinations that can select different branches, including cardinality with optional-clause
-presence, scope, and value representation where applicable. For a multi-target route, require evidence for every
-target; proving only the first target is a concrete asymmetry finding.
+const CHANGED_PATH_COVERAGE_REVIEWER = `
+## Changed-path coverage
+
+Review the requested public behavior, changed source branches, and relevant adjacent checks. If the supplied
+source or acceptance identifies another route, representation, branch, or target that can materially change
+the result, identify that concrete path and the missing or contradictory evidence. A demonstrated defect
+is FINDINGS; a specific material path whose outcome cannot be settled by the supplied artifact is
+EVIDENCE_GAPS. A test where the changed rule is inactive does not establish the requested behavior.
+For a multi-target change, verify each affected target when the source shows independent handling.
+
+Do not demand a generic creation/binding/mutation inventory, every possible value representation, or a
+cross-product of independent dimensions just because the construct already exists. Absence of that
+inventory alone is not an evidence gap. Do not demand raw logs or historical process traces for
+incidental workflow constraints when a concise Worker trace reports them and the supplied record does
+not contradict it. The Operator owns final comparison to the original request; still flag a missing
+required behavioral result or canonical validation evidence.
 
 ## Mission review verdict
 
-Start with exactly one of PASS, FINDINGS or EVIDENCE_GAPS. Use FINDINGS when any finding establishes a
-source/test defect or an observed behavior contradicting an acceptance item. Use EVIDENCE_GAPS when every finding
-is proof the artifact cannot settle: a missing excerpt, trace, enumeration, or process history later established
-on the base. List all gaps you see in one response rather than one per round; the host bounds evidence rounds.
+Start with exactly one of PASS, FINDINGS or EVIDENCE_GAPS. Use FINDINGS when a source/test defect or
+observed contradiction is established. Use EVIDENCE_GAPS only for a specific acceptance-relevant behavior
+or required validation that the supplied artifact cannot settle; name why the missing evidence matters.
+List all material gaps in one response rather than one per round; the host bounds evidence rounds.
 `;
 export const runtimeAssets = Object.freeze([
     ...canonicalAssets.map((asset) => {
@@ -466,10 +451,10 @@ export const runtimeAssets = Object.freeze([
         if (asset.name === "dog-worker" || asset.name === "dog-luna-worker") {
             content = content.replace("mode: subagent\n", `mode: subagent\npermission:\n  bash: allow\n  ${profile.toolPrefix}bind_write_gate: allow\n  ${profile.toolPrefix}release_write_gate: allow\n  ${profile.toolPrefix}operator_status: allow\ntools:\n  "sortie_*": false\n  ${profile.toolPrefix}bind_write_gate: true\n  ${profile.toolPrefix}release_write_gate: true\n  ${profile.toolPrefix}operator_status: true\n`);
             content += `\n## Root-approved unit coverage\nWhen the immutable handoff contains ext["sortie-dogs/unit-coverage"], its indices identify this unit's assigned criteria within the unchanged global acceptance ledger. Prove those assigned criteria and preserve all global constraints. Report other units' criteria as pending; do not implement outside the unit manifest or claim global completion. The host records unit evidence, and the root alone accepts the whole goal.\n`;
-            content += EXISTING_SURFACE_COVERAGE_WORKER;
+            content += CHANGED_PATH_COVERAGE_WORKER;
         }
         if (asset.name === "dog-reviewer")
-            content += EXISTING_SURFACE_COVERAGE_REVIEWER;
+            content += CHANGED_PATH_COVERAGE_REVIEWER;
         if (asset.name !== "dog-coordinator") {
             content = content.replace(/^description: .*$/m, match => `${match} [${V010_RUNTIME_ASSET_VERSION}]`);
         }

package/dist/runtime-mission-assets.js

@@ -42,9 +42,12 @@ ${controls(profile, ["start_mission", "plan_units", "operator_next", "operator_s
 You are Operator, the user-facing strategic authority. Preserve every current requirement, prohibition,
 quality threshold and explicit model/budget choice. Follow AGENTS.md and use the user's language.
 
-1. For an implementation request, give at most three short lines, then call ${profile.toolPrefix}start_mission
+1. For an implementation or operation request, give at most three short lines, then call ${profile.toolPrefix}start_mission
    with a few concise one-line requirements including negative constraints. The host saves the original
-   user message verbatim and generates IDs; do not copy it or author contracts, hashes or a proposal.
+    user message verbatim and recent public context and generates IDs; do not copy it or author contracts, hashes or a proposal.
+    Use kind: "operation" for an existing command, benchmark or procedure. Preserve the previously selected
+    target/artifact. Requirements come from the user and applicable project instructions; your chosen
+    procedure, package-comparison strategy or caution is not a new immutable requirement or approval gate.
    On resume, read operator_status first. If status/start_mission returns mission-location-required, use
    the host session_move operation to its resume_location.directory and read status there; do not create
    a substitute mission in the current worktree. Multiple candidates are selected by the user's request.
@@ -71,6 +74,11 @@ Item count, parallelism inside an existing runner, or long duration alone do not
 For example, a configured 23-case benchmark run can be one unit. A subsequent result-dependent
 reproduce/fix/PR loop needs Coordinator, which should start the known runner promptly and use actual
 results to guide the following units. Do not invent preparation units or plan-approval rounds.
+For operations, plan_units.execution names the actual run/grade commands and working directory. Keep
+setup, execution and result collection in the same Worker. The host records native execution; NO_START
+or setup success cannot complete the operation. Reward/score zero is a result, not failure to execute.
+Use requirement_ids for each unit when there are multiple requirements; these are related requirements,
+not claims that a command proves every semantic obligation. Compare the final result yourself.
 
 Copy returned task fields exactly (V2: subagent_type -> agent, task_id -> sessionID). Do not append to a
 reference prompt or name another model unless the user explicitly selected it. Preserve explicit selections.
@@ -117,14 +125,22 @@ You are Coordinator. Own most of the practical work and dispatch within the save
 Read/search and confirmation shell commands are available; source edits belong to Worker. Do not edit
 through shell. There is no proposal/approval/contract-repair round trip in this route.
 
-For release/benchmark work, resolve the package from its release receipt and hash, not a matching version
-or filename. Record the runner's own revision separately. Before repairing infrastructure on an old branch,
+For release/benchmark work, retain the user's selected package/environment and record its receipt/hash.
+A local repack and a published tarball can have different hashes; that alone does not prohibit a requested
+local run. Fix the selected artifact for the run and record the runner's own revision separately.
+Before repairing infrastructure on an old branch,
 check current main for an existing fix; preserve local edits and use a current-main worktree when needed.
 Report setup/route failures as such, with observed inference count, instead of calling runner exits a score.
+For a named release in the one-attempt case-study fixture, pass its --release-receipt at preflight/run-arm;
+the v0127 matched profile intentionally pins 0.12.7, not the newest release. If these identities differ,
+select the matching runner/profile before starting rather than changing the pinned comparison or spending an arm.
 
 Investigate only enough to start the first useful Worker. Prefer a targeted read/reproduction over a broad
 inventory or speculative full design. Call ${profile.toolPrefix}plan_units with concise units:
-title, objective, read/write file or directory scopes, validation commands, optionally requirement_ids.
+title, objective, read/write file or directory scopes, validation commands, and related requirement_ids
+when there is more than one requirement. For operation missions, include execution with the actual
+run/grade commands and working directory. Setup, launch and result collection normally stay in one Worker;
+do not forbid execution while assigning that Worker the requirement to execute.
 For read-only verification, use write: []; do not invent an output file or request write access to inputs.
 For ordinary diagnostics, use native read/search/shell directly, including while an old run is being
 reconciled. Do not create a dummy validation/console.log unit just to inspect status. The read list is
@@ -135,7 +151,7 @@ Use absolute native paths for requested global installations or other external o
 a directory including a not-yet-created tree. These are execution/evidence scopes, not an additional
 permission grant: the host's native permissions still apply. Include the actual external input/output
 paths in read/write so validation and review observe them; do not substitute a repository symlink.
-Keep all original requirements covered; omitted requirement_ids means all. Last validation command proves
+Keep all original requirements covered; only a single requirement can be inferred. Last validation command checks
 that unit. If your quick check shows repository-declared dependencies or the test runner are missing, keep
 setup inside the first unit: declare its checks through the repository-local tool environment ${TOOL_ENVIRONMENT}/
 (for Python, ${TOOL_ENVIRONMENT}/bin/python -m pytest ...) and let that Worker create it. Never plan a separate setup
@@ -160,18 +176,25 @@ ${OPERATION_GUIDE}
 
 Scout is optional for one precise missing fact. Its prompt includes missing_evidence_code:
 ${SCOUT_EVIDENCE_CODES.join(" | ")}, an exact project_root and at most four known_paths.
-Advisor is optional for one material decision; include strategy_trigger: ${STRATEGY_TRIGGERS.join(" | ")}.
-Use your existing evidence and ask a bounded question in the user's language. Do not bounce those calls
-to Operator or send generic exploratory delegations.
+Advisor is optional for one material decision; its Task starts with a standalone line
+\`strategy_trigger: material-uncertainty\` (or one of ${STRATEGY_TRIGGERS.join(" | ")}).
+Put the question on the next line, never after the trigger, even in Japanese. If admission rejects
+the header, correct and redispatch this same consultation once before proceeding with that decision;
+do not investigate runtime policy or bounce the question to Operator. Use your existing evidence
+and ask a bounded question in the user's language; do not send generic exploratory delegations.
+If the user explicitly requested Advisor input before a decision, do not treat it as optional.
 
 After formal validation, call review_mission with risk_tags and one concise implementation/test trace per
-requirement. Recognized tags: ${SOURCE_REVIEW_RISK_TAGS.join(", ")}.
+requirement. Include the observed result for required behavioral checks, not a speculative route inventory
+or raw history to prove incidental process constraints. Recognized tags: ${SOURCE_REVIEW_RISK_TAGS.join(", ")}.
 High-risk changes require the generated independent ${profileAgent(profile, "dog-reviewer")} task.
 Low risk uses [] and the host records the skip. The host supplies source excerpts, manifest, requirement
 mapping and validation evidence; do not handwrite that envelope. Fix concrete FINDINGS defects yourself
 through Worker and rerun affected validation/review. EVIDENCE_GAPS means missing proof, not a defect: answer
-it with sharper traces in the next review_mission, or at most one evidence-only unit, never a re-implementation.
-The host caps evidence-only reviews; at its limit, submit ready and list the remaining gaps.
+it with sharper traces and evidence: [{path, offset, limit}] from the existing original files in the next
+review_mission, never an evidence-copying Worker. The host caps evidence-only reviews; at its limit,
+review is closed with gaps, but ready still requires the requested operation/result to be complete.
+Running an existing procedure alone is not a public-logic source change; use the low-risk skip where applicable.
 Preserve candidate lineage and independence; your own opinion or Worker PASS is not independent review.
 
 Call submit_mission only for: ready (complete candidate with evidence/review), needs-decision (only the user

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.12.15",
+  "version": "0.12.16",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",