sortie-dogs 0.12.10 → 0.12.11

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.10-mission-continuity-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.11-operation-recovery-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.10-mission-continuity-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.11-operation-recovery-v1";

package/dist/core/operator-mission.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { normalizeRelativePath } from "./path.js";
+import { normalizeRelativeScope } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
@@ -286,7 +286,7 @@ export function missionPlan(mission, raw) {
             const entries = value[field] ?? [];
             if (!Array.isArray(entries) || !entries.every(item => typeof item === "string"))
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
-            return [...new Set(entries.map(item => normalizeRelativePath(item)))];
+            return [...new Set(entries.map(item => normalizeRelativeScope(item)))];
         };
         const ids = value.requirement_ids ?? mission.requirements.map(item => item.id);
         if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id => mission.requirements.some(item => item.id === id))) {
@@ -336,6 +336,12 @@ export function missionPacket(mission, run) {
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
         submission: mission.submission, progress: mission.progress,
+        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,
+            failed_units: run?.units.filter(unit => unit.status === "failed").length ?? 0,
+            historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,
+            accepted: mission.phase === "completed" },
         review: mission.review ? { risk_tags: mission.review.risk, verdict: mission.review.verdict,
             run_id: mission.review.runID, current_run: currentReview,
             source_fingerprint: mission.review.source, reviewer_session_id: mission.review.child ?? null,

package/dist/core/operator-runtime.js

@@ -5,7 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { acceptanceContinuityFingerprint, inspectAcceptanceContinuity, normalizeAcceptanceCriteria, ACCEPTANCE_CONTINUITY_EXTENSION, MAX_ACCEPTANCE_CONTINUITY_BYTES, MAX_ACCEPTANCE_CRITERIA } from "./acceptance-continuity.js";
 import { expandGoalDeclaration, goalDeclarationDefaults, goalDeclarationFieldDiagnostics, hasGoalCommandAliasConflict } from "./goal-declaration-format.js";
-import { normalizeManifestPath, normalizeRelativePath } from "./path.js";
+import { normalizeManifestPath, normalizeManifestScope, normalizeRelativePath } from "./path.js";
 import { CONTRACT_TEXT_LIMITS, validateHandoffSchema, validateOperationManifestSchema } from "./validate-schema.js";
 import { validateManifest } from "./validate-manifest.js";
 import { profileAgent, RUNTIME_PROFILES } from "./runtime-profile.js";
@@ -44,7 +44,10 @@ const text = (value) => typeof value === "string" && value.trim().length > 0 &&
 export function operatorGitPathAuthorized(path, scopes, platform = process.platform) {
     const key = (value) => platform === "win32" ? value.toLowerCase() : value;
     const candidate = key(path);
-    return scopes.some(scope => candidate === key(scope) || candidate.startsWith(`${key(scope)}/`));
+    return scopes.some(scope => {
+        const base = key(normalizeManifestScope(scope).path);
+        return candidate === base || candidate.startsWith(`${base}/`);
+    });
 }
 const contractError = (diagnostic) => { throw new OperatorContractError([diagnostic]); };
 const planError = (pointer, code, rule, repair_kind = "repair-field") => contractError({ document: "plan", pointer, code, rule, repair_kind });

package/dist/core/path.d.ts

@@ -21,3 +21,10 @@ export declare function normalizeRelativePath(input: string): string;
  * error instead of being resolved away.
  */
 export declare function normalizeManifestPath(input: string): ManifestPath;
+/** A trailing /** (or slash) declares a directory, including one not created yet.
+ * Tool destinations still use normalizeManifestPath: this notation belongs to declarations only.
+ */
+export declare function normalizeManifestScope(input: string): ManifestPath & {
+    readonly directory: boolean;
+};
+export declare function normalizeRelativeScope(input: string): string;

package/dist/core/path.js

@@ -52,3 +52,18 @@ export function normalizeManifestPath(input) {
     }
     return { kind: "relative", path: normalizeRelativePath(input) };
 }
+/** A trailing /** (or slash) declares a directory, including one not created yet.
+ * Tool destinations still use normalizeManifestPath: this notation belongs to declarations only.
+ */
+export function normalizeManifestScope(input) {
+    const unified = input.replaceAll("\\", "/");
+    const directory = unified.endsWith("/**") || unified.endsWith("/");
+    const path = unified.endsWith("/**") ? unified.slice(0, -3) : unified;
+    return { ...normalizeManifestPath(path), directory };
+}
+export function normalizeRelativeScope(input) {
+    const scope = normalizeManifestScope(input);
+    if (scope.kind !== "relative")
+        throw new RelativePathError("absolute");
+    return scope.path + (scope.directory ? "/**" : "");
+}

package/dist/core/validate-manifest.js

@@ -31,7 +31,7 @@ function collectManifestPaths(paths, pointer, diagnostics) {
     paths.forEach((path, index) => {
         let normalized;
         try {
-            normalized = pathUtils.normalizeManifestPath(path);
+            normalized = pathUtils.normalizeManifestScope(path);
         }
         catch (error) {
             if (!(error instanceof pathUtils.RelativePathError))
@@ -48,7 +48,7 @@ function collectManifestPaths(paths, pointer, diagnostics) {
         else if (normalized.kind === "relative") {
             // Absolute manifest targets authorize tools only. Handoff scope/source and Git paths remain
             // repository-relative and therefore never compare equal to an external target.
-            normalizedPaths.add(normalized.path);
+            normalizedPaths.add(normalized.path + (normalized.directory ? "/**" : ""));
         }
     });
     return normalizedPaths;
@@ -79,7 +79,7 @@ function addPathDiagnostics(diagnostics, paths, allowed, code, pointer) {
     const reported = new Set();
     paths.forEach((path, index) => {
         const normalized = normalizePath(path);
-        if (normalized !== undefined && (allowed.has(normalized) || reported.has(normalized)))
+        if (normalized !== undefined && (scopeAllows(allowed, normalized) || reported.has(normalized)))
             return;
         if (normalized !== undefined)
             reported.add(normalized);
@@ -91,6 +91,10 @@ function addPathDiagnostics(diagnostics, paths, allowed, code, pointer) {
         });
     });
 }
+function scopeAllows(scopes, path) {
+    return scopes.has(path) || [...scopes].some(scope => scope.endsWith("/**") &&
+        (path === scope.slice(0, -3) || path.startsWith(scope.slice(0, -2))));
+}
 /** Compare one schema-valid handoff with one schema-valid operation manifest. */
 export function validateManifest(handoff, manifest, changedPaths, changedPathsProvided, options = {}) {
     const diagnostics = [];
@@ -105,7 +109,7 @@ export function validateManifest(handoff, manifest, changedPaths, changedPathsPr
     handoff.sources?.forEach((source, index) => {
         const normalized = normalizePath(source.path);
         if (normalized !== undefined &&
-            (readableOrWritable.has(normalized) || reportedSources.has(normalized)))
+            (scopeAllows(readableOrWritable, normalized) || reportedSources.has(normalized)))
             return;
         if (normalized !== undefined)
             reportedSources.add(normalized);

package/dist/plugin/gate.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, win32 } from "node:path";
 import { promisify } from "node:util";
-import { RelativePathError, normalizeManifestPath, normalizeRelativePath } from "../core/path.js";
+import { RelativePathError, normalizeManifestPath, normalizeManifestScope, normalizeRelativePath } from "../core/path.js";
 import { validateOperationManifestSchema } from "../core/validate-schema.js";
 export class WriteDeniedError extends Error {
     reason;
@@ -144,6 +144,13 @@ function curlOutput(tokens) {
                 return undefined;
             continue;
         }
+        if (token === "-w" || token === "--write-out" || token.startsWith("--write-out=")) {
+            const format = token.startsWith("--write-out=") ? token.slice(12) : tokens[++index];
+            // curl write-out can open additional files or read a format file. Only stdout metadata is pathless.
+            if (format === undefined || format.startsWith("@") || /%output\{/u.test(format))
+                return undefined;
+            continue;
+        }
         if (token === "-o" || token === "--output") {
             const candidate = tokens[++index];
             if (candidate === undefined || candidate.startsWith("-") || output !== undefined)
@@ -259,8 +266,40 @@ function isRemoteGitHubMutation(tokens) {
 function isReadOnlyGitCommand(tokens) {
     const command = tokens[1]?.toLowerCase() ?? "";
     return READ_ONLY_GIT_COMMANDS.has(command) ||
+        (command === "tag" && tokens.length >= 3 && ["--points-at", "--contains", "--list", "-l"].includes(tokens[2]) &&
+            tokens.slice(3).every(token => !token.startsWith("-"))) ||
         (command === "branch" && tokens.length === 3 && tokens[2] === "--show-current");
 }
+function gitArchiveOutput(tokens) {
+    let output, tree = false, paths = false;
+    for (let index = 2; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === "--" && tree) {
+            paths = true;
+            continue;
+        }
+        if (paths || !token.startsWith("-")) {
+            tree = true;
+            continue;
+        }
+        if (token === "-o" || token === "--output") {
+            const value = tokens[++index];
+            if (!value || value.startsWith("-") || output !== undefined)
+                return undefined;
+            output = value;
+        }
+        else if (token.startsWith("--output=")) {
+            if (output !== undefined || !token.slice(9))
+                return undefined;
+            output = token.slice(9);
+        }
+        else if (/^--(?:format|prefix)=.+$/u.test(token) || /^-[0-9]$/u.test(token))
+            continue;
+        else
+            return undefined;
+    }
+    return tree ? { output } : undefined;
+}
 function exactGitAddPaths(tokens) {
     if (tokens.length < 4 || tokens[2] !== "--")
         return undefined;
@@ -632,6 +671,18 @@ function shellPaths(command, powershell, depth = 0) {
             else
                 ambiguous = true;
         }
+        else if (executable === "git" && tokens[1] === "archive") {
+            const archive = gitArchiveOutput(tokens);
+            if (archive === undefined) {
+                applies = true;
+                ambiguous = true;
+                issue ??= commandIssue(source, "unsupported-git-archive-form", "use git archive --format=tar --output=<scoped-file> <local-ref>");
+            }
+            else if (archive.output !== undefined) {
+                applies = true;
+                paths.push(archive.output);
+            }
+        }
         else if (executable === "git" && isReadOnlyGitCommand(tokens)) {
             // Explicitly read-only git subcommands.
         }
@@ -677,8 +728,10 @@ function shellPaths(command, powershell, depth = 0) {
         ...(issue ? { issue } : {}),
     };
 }
-function issuePath(issue) {
-    return `segment=${issue.segment}; cause=${issue.cause}; hint=${issue.hint}; retry=false; action=return-denial-to-coordinator`;
+function issuePath(issue, formatCorrection = false) {
+    return `segment=${issue.segment}; cause=${issue.cause}; hint=${issue.hint}; ` + (formatCorrection
+        ? "retry=after-format-correction; action=correct-format-within-current-manifest; preserve operation and destinations; otherwise return exact required correction to Coordinator"
+        : "retry=false; action=return-denial-to-coordinator");
 }
 export function describeUnclassifiedCommand(tool, args) {
     const extracted = extractWritePaths(tool, args);
@@ -925,7 +978,7 @@ function isWithin(root, target) {
 }
 async function canonicalManifestScopes(project, entries) {
     const scopes = await Promise.all(entries.map(async (entry) => {
-        const normalized = normalizeManifestPath(entry);
+        const normalized = normalizeManifestScope(entry);
         const absolute = normalized.kind === "relative"
             ? project.absolute(normalized.path)
             : resolve(normalized.path);
@@ -987,10 +1040,13 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
         }
     }
     const writable = new Set();
+    const explicitDirectories = new Set();
     const externalEntries = [];
     try {
         for (const entry of manifest.write) {
-            const normalized = normalizeManifestPath(entry);
+            const normalized = normalizeManifestScope(entry);
+            if (normalized.directory)
+                explicitDirectories.add(normalized.path);
             if (normalized.kind === "relative")
                 writable.add(normalized.path);
             else {
@@ -1015,7 +1071,7 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
             }
         }
         catch (error) {
-            if ((declaredDirectories.has(path) || inferredDirectories.has(path)) &&
+            if ((explicitDirectories.has(path) || declaredDirectories.has(path) || inferredDirectories.has(path)) &&
                 isRecord(error) && error.code === "ENOENT") {
                 writableDirectories.push({ path, realPath: await nearestExistingRealPath(project.absolute(path)) });
             }
@@ -1059,7 +1115,11 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
             if (!isRecord(error) || error.code !== "ENOENT") {
                 throw new WriteDeniedError("manifest-unavailable", "<unknown>", { cause: error });
             }
-            externalFiles.push({ path, anchorRealPath: await nearestExistingRealPath(resolve(path, "..")) });
+            if (explicitDirectories.has(path.replaceAll("\\", "/"))) {
+                externalDirectories.push({ path, realPath: await nearestExistingRealPath(path) });
+            }
+            else
+                externalFiles.push({ path, anchorRealPath: await nearestExistingRealPath(resolve(path, "..")) });
         }
     }
     const matchingExternalScopes = (absolute) => ({
@@ -1192,7 +1252,9 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
                 return;
             if (extracted.ambiguous || (extracted.paths.length === 0 && !extracted.gitCommit)) {
                 if (extracted.issue !== undefined) {
-                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue));
+                    const formatCorrection = options?.investigativeShell === true &&
+                        ["unsupported-curl-form", "unsupported-git-archive-form", "unsupported-webrequest-form"].includes(extracted.issue.cause);
+                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue, formatCorrection));
                 }
                 throw new WriteDeniedError("path-required", "<missing-path>");
             }
@@ -1208,7 +1270,15 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
                         throw new WriteDeniedError("project-boundary", path, { cause: error });
                     }
                 }
-                await checkPath(nativeFileTool ? resolve(toolDirectory, path) : path);
+                try {
+                    await checkPath(nativeFileTool ? resolve(toolDirectory, path) : path);
+                }
+                catch (error) {
+                    if (options?.investigativeShell && error instanceof WriteDeniedError && error.reason === "manifest-scope") {
+                        error.message += " Coordinator: expand_unit with the exact missing output directory as dir/**, preserving settled units and cumulative spend; then dispatch the returned Task. No user approval is needed for an in-request correction.";
+                    }
+                    throw error;
+                }
             }
             if (extracted.gitCommit)
                 await checkCachedSet();

package/dist/plugin/index.js

@@ -7760,7 +7760,10 @@ export const SortieDogsPlugin = async (input, options) => {
                 return null;
             const reserved = state.outstanding_reservations.length;
             return { max_units: state.budget.max_units, consumed_units: state.consumed_units,
-                reserved_units: reserved, remaining_units: Math.max(0, state.budget.max_units - state.consumed_units - reserved) };
+                reserved_units: reserved, remaining_units: Math.max(0, state.budget.max_units - state.consumed_units - reserved),
+                settled_cost_usd: state.consumed_cost_usd, cost_limit_usd: state.budget.cost_usd,
+                cost_status: state.consumed_cost_usd === null ? "unknown-usage" : reserved > 0 ? "in-flight-not-final" : "settled",
+                cost_note: "Goal Worker ledger only; excludes unfinalized native requests, orchestration/review and external campaign spend. Zero settled cost does not mean free execution." };
         },
         registerGoalDeclaration: async (root, prompt, missionRevision) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))

package/dist/plugin/mission-review.js

@@ -8,6 +8,7 @@ import { TOOL_ENVIRONMENT } from "../runtime-mission-assets.js";
 import { MISSION_REVIEW_REFERENCE } from "../core/operator-mission.js";
 import { canonicalAgent } from "../core/runtime-profile.js";
 import { taskChildSessionID } from "./task-result-repair.js";
+import { normalizeManifestScope } from "../core/path.js";
 const exec = promisify(execFile);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 /** Recover from native completion records, never from the pending review's inherited child ID. */
@@ -75,7 +76,7 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
 /** Pin all scoped tracked/untracked source bytes, including deletions; display a bounded excerpt only. */
 export async function missionReviewSource(directory, run) {
     const hash = createHash("sha256").update(JSON.stringify(run.units.map(unit => ({ unit: unit.unit, hashes: unit.hashes }))));
-    const writes = [...new Set(run.units.flatMap(unit => unit.unit.write))];
+    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.]" };

package/dist/plugin/profiled.js

@@ -1277,7 +1277,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             });
             return JSON.stringify(await operators.next(root, actor));
         }
-        tools[planUnits] = { description: "Coordinator (or single-unit Fast-lane Operator): declare useful units, then dispatch the returned Worker immediately. Host generates IDs, handoff, manifest and proof mapping. Keep every original requirement covered. Use write: [] for read-only verification; do not invent a write path. Final validation command in each unit proves that unit; read-only diagnostic commands need no registration. Recalling with reason replaces settled work within unchanged requirements and cumulative budget; include required scope extensions here. Rejected budget, contract or control-storage preparation preserves the existing run so you can correct the plan directly.",
+        tools[planUnits] = { description: "Coordinator (or single-unit Fast-lane Operator): declare useful units, then dispatch the returned Worker immediately. Host generates IDs, handoff, manifest and proof mapping. Keep every original requirement covered. Use write: [] for read-only verification; use dir/** for directory outputs including not-yet-created trees. Final validation command in each unit proves that unit; read-only diagnostic commands need no registration. Recalling with reason replaces settled work within unchanged requirements and cumulative budget; include required scope extensions here. Rejected budget, contract or control-storage preparation preserves the existing run so you can correct the plan directly.",
             args: { units: { type: "array", minItems: 1, maxItems: 32, items: { type: "object", additionalProperties: false,
                         properties: { title: { type: "string" }, objective: { type: "string" }, read: stringList, write: stringList,
                             validation: stringList, requirement_ids: stringList }, required: ["title", "objective", "write", "validation"] } },

package/dist/plugin/protected-snapshot.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { lstat, readFile, readdir, readlink, realpath, stat } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { goalFingerprint } from "../core/goal-bound.js";
-import { normalizeManifestPath } from "../core/path.js";
+import { normalizeManifestScope } from "../core/path.js";
 import { RUNTIME_PROFILES } from "../core/runtime-profile.js";
 const controlRoots = new Set([".git", ...Object.values(RUNTIME_PROFILES).map(profile => profile.stateDirectory)]);
 /** Live orchestration/Git bookkeeping is readable context, not the source being validated. */
@@ -67,7 +67,7 @@ export async function protectedSnapshot(authorization) {
     const relativePath = relative(authorization.projectRoot, authorization.manifestPath).replaceAll("\\", "/");
     const manifest = JSON.parse(manifestSource.toString("utf8"));
     const actualPaths = (entries) => entries.map((entry) => {
-        const path = normalizeManifestPath(entry);
+        const path = normalizeManifestScope(entry);
         return path.kind === "relative" ? resolve(authorization.projectRoot, path.path) : resolve(path.path);
     });
     const candidatePaths = actualPaths(manifest.write);

package/dist/runtime-mission-assets.js

@@ -3,6 +3,17 @@ import { STRATEGY_TRIGGERS, SOURCE_REVIEW_RISK_TAGS } from "./core/consultation.
 import { SCOUT_EVIDENCE_CODES } from "./core/scout-contract.js";
 /** Repository-local dependency environment shared by all units; excluded from reviewed and captured source. */
 export const TOOL_ENVIRONMENT = ".sortie-env";
+const OPERATION_GUIDE = `## Practical operation guide
+
+Use file paths for exact outputs and dir/** for a directory tree, including a directory that does not
+exist yet. The host interprets dir/** consistently for writes, validation fingerprints and review.
+Create the directory with mkdir -p dir; do not add parent directories merely to make child writes work.
+For local source snapshots use git archive --format=tar --output=dir/source.tar <local-ref>.
+For tag observation use git tag --points-at <commit>. For HTTPS downloads use curl -fLsS -o dir/file <url>;
+--write-out '%{http_code} %{size_download}\\n' may print metadata to stdout. Declare all actual outputs.
+Reuse pinned artifacts and successful checks when the request permits and the inputs are unchanged.
+Do not repeat candidate discovery, dependency setup or validation merely because a Worker changed.
+`;
 function controls(profile, names) {
     return names.map(name => `  ${profile.toolPrefix}${name}: true`).join("\n");
 }
@@ -62,6 +73,10 @@ Ordinary defects return to Coordinator, not the user. Ask through question only
 an extension beyond the original requirements, or a cumulative budget increase. Resume the same work after
 the answer. Do not reset spend, silently shrink acceptance, or create substitute goals.
 
+When bounded process reflections are injected, pass the relevant prevention in Coordinator feedback while
+preserving the original requirements. After a resolved repeated process failure, record its verified cause/prevention
+through reflection if enabled; retain concrete evidence and prefer a durable fix for recurring causes.
+
 Retain 🐾 Sortie presentation and measured return panels. Append complete_mission's return_report verbatim
 once. Do not invent scores, medals, costs, savings, models or successful checks. Release/publish requires the
 existing user authorization and project gates; npm publication remains manual.
@@ -114,10 +129,14 @@ check or reviewer finding, call plan_units with the corrected units and a short
 preserves every requirement, failed-check history and cumulative budget. Never replace an active Worker.
 Rejected budget/contract checks or control-storage preparation leave the old run available. Correct the
 reported cause and call plan_units again; a local plan repair needs no cancellation or user approval.
+On a returned denial, correct the exact command form or output scope before redispatch; reuse established
+candidate identity, setup and evidence in the next objective instead of requesting the entire investigation again.
 Workers freely investigate within their unit and execute exact formal checks for host recording. Do not
 require them to predeclare exploratory commands. Require meaningful evidence, not extra testing for its
 own sake. Do not repeat passed checks unless source changes or unresolved concerns justify it.
 
+${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(" | ")}.
@@ -183,7 +202,13 @@ are complete. Never fabricate logs, costs or exits. Do not stage outside declare
 publish, or take over Coordinator decisions. The parent releases your write binding after return.
 
 A local tool/permission/handoff defect returns PROCESS_DEFECT: local: <condition> and its exact diagnostic
-once to Coordinator. Do not repeat the same refused operation. Only a proven external dependency or
+once to Coordinator when its remedy requires a changed contract. If the host explicitly returns
+action=correct-format-within-current-manifest, correct the supported command form in this same Task,
+preserving the operation, inputs and destinations, then continue. An unchanged denied request is not a correction.
+If correcting the form changes the intended operation or requires another output, return the exact required
+correction to Coordinator. Do not repeat the same refused operation. Only a proven external dependency or
 user-only choice uses TRUE_BLOCKER: external: <condition> or TRUE_BLOCKER: user-decision: <condition>.
+
+${OPERATION_GUIDE}
 `;
 }

package/package.json

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