sortie-dogs 0.12.23 → 0.12.25

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.23-mission-budget-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.25-mission-continuity-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.23-mission-budget-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.25-mission-continuity-v1";

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

@@ -174,7 +174,7 @@ export declare class OperatorMissionRuntime {
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
     private load;
-    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     private loadMission;
     /** Find exactly one archived cancelled mission that owned this run; ambiguity never grants recovery. */
     archivedRun(root: string, runID: string): Promise<OperatorMission | undefined>;

package/dist/core/operator-mission.js

@@ -113,10 +113,10 @@ export class OperatorMissionRuntime {
             throw error;
         }
     }
-    /** Recover the predecessor link for missions started before this fix, using one exact archived mission. */
+    /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     async loadMission(root) {
         const state = await this.load(this.file(root));
-        if (!state || state.supersededRunID !== undefined || state.runID !== null ||
+        if (!state || state.supersededRunID !== undefined || state.runID !== null || state.requirementsReplaced ||
             !["open", "running", "submitted", "cancelled"].includes(state.phase) || state.requests.length === 0)
             return state;
         const directory = join(this.projectRoot, this.profile.stateDirectory, "missions");
@@ -241,8 +241,9 @@ export class OperatorMissionRuntime {
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
-            // A cancelled standalone/legacy run has no mission-owned runID. Only an explicit
-            // replacement may link it; normal continuation must not silently inherit its goal.
+            // Explicit replacement links the latest cancelled run even when a user narrows the
+            // request in the same turn. Ordinary same-turn continuation still retains acceptance.
+            // A cancelled standalone/legacy run has no mission-owned runID; only replacement links it.
             const predecessor = previous?.runID ?? previous?.supersededRunID ??
                 (replaceRequirements ? options.cancelledRunID : undefined);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
@@ -252,7 +253,7 @@ export class OperatorMissionRuntime {
                 ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
                 ...((previous === undefined || previous.phase === "cancelled") &&
-                    (previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
+                    (replaceRequirements || previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
                     ? { supersededRunID: predecessor } : {}) };
             await this.save(this.file(root), state);
             return state;

package/dist/plugin/declared-artifacts.d.ts

@@ -1,8 +1,11 @@
 /** Explicit external artifacts are filesystem inputs, not Git pathspecs. Stream complete bytes;
  * previews are bounded independently. Follow package links only inside a declared physical root.
  */
-export declare function declaredArtifacts(paths: readonly string[], previewLimit?: number): Promise<{
+export declare function declaredArtifacts(paths: readonly string[], previewLimit?: number, options?: {
+    reportUnreadableDirectories?: boolean;
+}): Promise<{
     entries: (readonly [string, string, (string | undefined)?])[];
     excerpt: string;
     truncated: boolean;
+    unreadable: string[];
 }>;

package/dist/plugin/declared-artifacts.js

@@ -9,7 +9,7 @@ const within = (root, path) => {
 /** Explicit external artifacts are filesystem inputs, not Git pathspecs. Stream complete bytes;
  * previews are bounded independently. Follow package links only inside a declared physical root.
  */
-export async function declaredArtifacts(paths, previewLimit = 0) {
+export async function declaredArtifacts(paths, previewLimit = 0, options = {}) {
     const roots = [...new Set(paths.map(path => resolve(path)))].sort();
     const physical = await Promise.all(roots.map(path => realpath(path).catch((error) => {
         if (error.code === "ENOENT")
@@ -18,6 +18,7 @@ export async function declaredArtifacts(paths, previewLimit = 0) {
     })));
     const entries = [];
     const excerpts = [];
+    const unreadable = [];
     let remaining = previewLimit, truncated = false;
     const visited = new Set();
     const visit = async (path, ancestors) => {
@@ -47,7 +48,26 @@ export async function declaredArtifacts(paths, previewLimit = 0) {
         if (metadata.isDirectory()) {
             entries.push([label, "directory", canonical]);
             const next = new Set([...ancestors, canonical]);
-            for (const child of (await readdir(path)).sort())
+            let children;
+            try {
+                children = await readdir(path);
+            }
+            catch (error) {
+                if (!options.reportUnreadableDirectories || !["EACCES", "EPERM"].includes(error.code ?? ""))
+                    throw error;
+                entries.push([label, `unreadable:${error.code}`, canonical]);
+                unreadable.push(label);
+                const notice = `\n--- external directory: ${label} ---\n[not inspected: permission denied; select specific result files as review evidence]\n`;
+                const bytes = Buffer.from(notice), bounded = bytes.subarray(0, remaining);
+                if (bounded.length) {
+                    excerpts.push(bounded.toString("utf8"));
+                    remaining -= bounded.length;
+                }
+                if (bounded.length < bytes.length)
+                    truncated = true;
+                return;
+            }
+            for (const child of children.sort())
                 await visit(join(path, child), next);
             return;
         }
@@ -76,5 +96,5 @@ export async function declaredArtifacts(paths, previewLimit = 0) {
     };
     for (const path of roots)
         await visit(path, new Set());
-    return { entries, excerpt: excerpts.join(""), truncated };
+    return { entries, excerpt: excerpts.join(""), truncated, unreadable };
 }

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

@@ -13,4 +13,5 @@ export declare function completedMissionReviewPrompts(mission: OperatorMission |
 export declare function missionReviewSource(directory: string, run: OperatorState, evidence?: readonly MissionEvidenceExcerpt[], baseline?: string, priorScope?: MissionReviewScope): Promise<{
     fingerprint: string;
     excerpt: string;
+    truncatedEvidence: string[];
 }>;

package/dist/plugin/mission-review.js

@@ -214,9 +214,11 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         if (needsNotice[index])
             selected += truncated(item.entry);
     }
+    const truncatedEvidence = focused.flatMap(({ entry }, index) => needsNotice[index] ? [`${entry.path}:${entry.offset}`] : []);
     if (writes.length === 0)
         return { fingerprint: `sha256:${hash.digest("hex")}`,
-            excerpt: selected + "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]" };
+            excerpt: selected + "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]",
+            truncatedEvidence };
     // The shared dependency environment is local tooling, never reviewed or pinned source.
     const external = [], local = [];
     for (const path of writes) {
@@ -230,12 +232,15 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
     const git = async (args) => (await exec("git", args, { cwd: directory, maxBuffer: 8 * 1024 * 1024 })).stdout;
     const names = local.length ? await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...scopes]) : "";
     const untracked = new Set((local.length ? await git(["ls-files", "-z", "--others", "--exclude-standard", "--", ...scopes]) : "").split("\0").filter(Boolean));
-    // Explicitly declared outputs are review evidence even when gitignored (for example a probe
-    // JSON in _testenv). Their bytes must participate in staleness checks as well as the excerpt.
-    const ignored = local.length ? await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...scopes]) : "";
+    // Go's ignored in-project caches may be writable during validation but are not candidate
+    // output. Keep every other ignored declared output visible and fingerprinted, including
+    // directories of generated artifacts; focused references can still pin a cache file.
+    const ignored = local.length ? await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--",
+        ...scopes, ...[".gocache", ".gomodcache", ".gopath"].map(path => `:(exclude)${path}`)]) : "";
     for (const path of ignored.split("\0").filter(Boolean))
         untracked.add(path);
     const omitted = [];
+    const unreadable = [];
     let diff = "";
     if (local.length && baseline) {
         // HEAD-only diffs are empty once the Worker commits. Show bounded changes from the
@@ -305,13 +310,19 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         }
     }
     if (external.length) {
-        const artifacts = await declaredArtifacts(external, Math.max(1, 24_000 - Buffer.byteLength(excerpt)));
+        // A declared write scope can also be a host-managed runtime directory (e.g. Docker's data root).
+        // Do not make review depend on listing it; record the missing coverage instead. Protected
+        // validation still requires readable outputs and does not use this review-only option.
+        const artifacts = await declaredArtifacts(external, Math.max(1, 24_000 - Buffer.byteLength(excerpt)), { reportUnreadableDirectories: true });
         hash.update(JSON.stringify(artifacts.entries));
         excerpt += artifacts.excerpt;
         if (artifacts.truncated)
             omitted.push("external artifacts");
+        unreadable.push(...artifacts.unreadable);
     }
     const bytes = Buffer.from(excerpt);
     return { fingerprint: `sha256:${hash.digest("hex")}`, excerpt: (bytes.length > 24_000 ? bytes.subarray(0, 24_000).toString("utf8") : excerpt) +
-            (bytes.length > 24_000 || omitted.length ? `\n[EXCERPT TRUNCATED: ${omitted.slice(0, 20).join(", ")}; supply focused traces for missing sections, not another implementation unit]` : "") };
+            (bytes.length > 24_000 || omitted.length ? `\n[EXCERPT TRUNCATED: ${omitted.slice(0, 20).join(", ")}; supply focused traces for missing sections, not another implementation unit]` : "") +
+            (unreadable.length ? `\n[UNINSPECTED EXTERNAL DIRECTORIES: ${unreadable.slice(0, 20).join(", ")}; select specific result files as review evidence]` : ""),
+        truncatedEvidence };
 }

package/dist/plugin/profiled.js

@@ -17,6 +17,7 @@ import { MISSION_EVIDENCE_GAP_REVIEW_LIMIT, OperatorMissionRuntime, missionPacke
 import { publishMissionProgress } from "./mission-progress.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionReviewBaseline, missionReviewSource } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
+import { prepareValidationScratch } from "./validation-scratch.js";
 import { SOURCE_REVIEW_RISK_TAGS } from "../core/consultation.js";
 import { createHash, randomUUID } from "node:crypto";
 import { proposeTerminalRescue } from "../core/terminal-rescue-policy.js";
@@ -580,10 +581,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 } : {}) };
         }
         function sourceReconciliationRequired(mission, previous) {
-            return previous?.phase === "cancelled" && !["completed", "cancelled"].includes(mission.phase) &&
-                mission.runID === null && mission.supersededRunID === undefined &&
-                (previous.sourceRefs[0] !== `user:${mission.requests[0]?.id}` ||
-                    !previous.sourceRefs.every(ref => mission.requests.some(request => ref === `user:${request.id}`)));
+            if (previous?.phase !== "cancelled" || ["completed", "cancelled"].includes(mission.phase) || mission.runID !== null)
+                return false;
+            if (mission.supersededRunID !== undefined)
+                return mission.supersededRunID !== previous.runID;
+            return mission.requirementsReplaced === true || previous.sourceRefs[0] !== `user:${mission.requests[0]?.id}` ||
+                !previous.sourceRefs.every(ref => mission.requests.some(request => ref === `user:${request.id}`));
         }
         async function missionAuthority(id) {
             const root = await rootFor(id);
@@ -666,7 +669,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (mission.phase === "submitted" && mission.submission?.status === "blocked" &&
                 run?.units.some(unit => unit.status === "running")) {
                 return { ...packet, next_action: `If the native Worker Task is still active, wait for it; do not start a duplicate. ` +
-                        `If its parent Task was interrupted and the user chose to stop/replan, Operator root (not Coordinator): ` +
+                        `If the parent Coordinator Task has finished or was interrupted, and the user chose to stop/replan, Operator root (not Coordinator): ` +
                         `call ${profile.toolPrefix}cancel_operator with reason=plain to stop owned children, then ` +
                         `${profile.toolPrefix}start_mission with intent=replace and the saved requirements. ` +
                         `Use the returned Coordinator Task; the previous Mission is archived and cumulative spend is retained.` };
@@ -674,7 +677,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (sourceReconciliationRequired(mission, run))
                 return { ...packet, status: "mission-source-reconciliation-required",
                     next_action: mission.dispatchOpen ? "The Coordinator Task is still active. Do not redispatch; wait for its native completion and reconcile via operator_status."
-                        : `The cancelled run's source_refs cannot prove this mission is the same goal. Do not dispatch or repeat plan_units. ` +
+                        : `The mission is not linked to the current cancelled run. Do not dispatch or repeat plan_units. ` +
                             `If these saved requirements reflect the user's changed or narrowed scope, Operator: call ${profile.toolPrefix}start_mission ` +
                             `with intent=replace and the exact requirements array shown here. The host repairs this mission in place, retains spend, ` +
                             `and verifies old children before preparing a Worker. Otherwise obtain the user's scope decision.` };
@@ -1696,7 +1699,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 return JSON.stringify({ ...missionDispatchPacket(mission, previous),
                     next_action: `Coordinator: do not repeat plan_units. Call ${submitMission} with status=blocked and report the saved ` +
                         `requirements to Operator. Operator can relink this mission in place via ${startMission} intent=replace ` +
-                        `when they match the user's changed scope; no Worker can start before that decision.` });
+                        `with those exact requirements when they match the user's changed scope; no Worker can start before that decision.` });
             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.
@@ -1780,7 +1783,15 @@ export function createProfiledPlugin(profile, assetVersion) {
                     item.execution = operation;
                 }
             });
-            return JSON.stringify(await operators.next(root, actor));
+            const next = await operators.next(root, actor);
+            if (!record(next) || !record(next.task))
+                return JSON.stringify(next);
+            const setup = await prepareValidationScratch(input.directory, plan.units.flatMap(unit => unit.validation));
+            return JSON.stringify(setup.prepared_directories.length || setup.unprepared_directories.length
+                ? { ...next, validation_setup: setup, ...(setup.unprepared_directories.length ? {
+                        next_action: "Before dispatch, correct or prepare the listed in-project TMPDIR directories. Keep this plan and its budget; no new approval or validation run is needed."
+                    } : {}) }
+                : next);
         }
         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. Native absolute paths support global installs and external outputs under host permissions; include their actual paths in read/write for evidence. 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,
@@ -1825,7 +1836,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return declareMissionUnits(root, context.sessionID, mission, units, args.reason);
                 });
             } };
-        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.",
+        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; if truncated_evidence is returned, narrow those ranges before dispatching the Reviewer. 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 } },
@@ -1881,7 +1892,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                         ...(initialPrompt ? { initialPrompt } : {}),
                         ...(mission.review?.evidenceGapReviews ? { evidenceGapReviews: mission.review.evidenceGapReviews } : {}) };
                 });
-                return JSON.stringify(task ? { status: "review-required", task: missionReviewTask(reviewed) } : { status: "skipped-low-risk" });
+                return JSON.stringify(task ? { status: "review-required", task: missionReviewTask(reviewed),
+                    ...(source.truncatedEvidence.length ? { truncated_evidence: source.truncatedEvidence,
+                        next_action: "Narrow these focused evidence ranges with review_mission before dispatching the Reviewer; no Worker or new validation is needed." } : {}) }
+                    : { status: "skipped-low-risk" });
             } };
         async function assertMissionReview(root, mission) {
             const run = await operators.required(root), review = mission.review;

package/dist/plugin/validation-scratch.d.ts

@@ -0,0 +1,5 @@
+/** Prepare only an explicitly declared, in-project TMPDIR before a Worker starts validation. */
+export declare function prepareValidationScratch(directory: string, commands: readonly string[]): Promise<{
+    prepared_directories: string[];
+    unprepared_directories: string[];
+}>;

package/dist/plugin/validation-scratch.js

@@ -0,0 +1,51 @@
+import { lstat, mkdir } from "node:fs/promises";
+import { isAbsolute, relative, resolve, win32 } from "node:path";
+import { createProjectPaths } from "./gate.js";
+import { RUNTIME_PROFILES } from "../core/runtime-profile.js";
+const controlDirectories = new Set([".git", ".opencode", ...Object.values(RUNTIME_PROFILES).map(profile => profile.stateDirectory)]);
+/** Prepare only an explicitly declared, in-project TMPDIR before a Worker starts validation. */
+export async function prepareValidationScratch(directory, commands) {
+    const prepared_directories = [], unprepared_directories = [];
+    if (!commands.some(command => /(?:^|\s)TMPDIR=/u.test(command)))
+        return { prepared_directories, unprepared_directories };
+    const project = await createProjectPaths(directory);
+    const seen = new Set();
+    for (const command of commands) {
+        for (const match of command.matchAll(/(?:^|\s)TMPDIR=(?:"([^"]+)"|'([^']+)'|([^\s"']+))/gu)) {
+            const declared = match[1] ?? match[2] ?? match[3];
+            // WSL's default drive mount and a native Windows project refer to the same directory.
+            // Other mounts are not inferred from command text.
+            const wsl = process.platform === "win32" ? /^\/mnt\/([a-z])\/(.+)$/iu.exec(declared) : null;
+            const target = wsl ? win32.resolve(`${wsl[1].toUpperCase()}:\\`, wsl[2].replaceAll("/", "\\"))
+                : isAbsolute(declared) ? resolve(declared) : null;
+            if (!target)
+                continue;
+            const path = relative(project.root, target).replaceAll("\\", "/");
+            if (!path || path === ".." || path.startsWith("../") || seen.has(path))
+                continue;
+            seen.add(path);
+            if (controlDirectories.has(path.split("/")[0]) || !await project.contains(target).catch(() => false)) {
+                unprepared_directories.push(path);
+                continue;
+            }
+            try {
+                const stat = await lstat(target).catch(error => {
+                    if (error.code === "ENOENT")
+                        return null;
+                    throw error;
+                });
+                if (stat?.isDirectory())
+                    continue;
+                if (stat)
+                    throw new Error("path is not a directory");
+                await mkdir(target, { recursive: true });
+                prepared_directories.push(path);
+            }
+            catch {
+                // Existing Worker dispatch remains available; the Coordinator sees the missing setup.
+                unprepared_directories.push(path);
+            }
+        }
+    }
+    return { prepared_directories, unprepared_directories };
+}

package/dist/runtime-mission-assets.js

@@ -173,6 +173,13 @@ Do not reconstruct or prepend the absolute workspace path. Preserve explicitly r
 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.
+Distinguish an outer benchmark attempt from the Worker dispatches inside it. If the user asked for no
+automatic retries, do not start another Worker or replacement run for an unchanged failed task. Report
+the host's actual attempt history and model observations, not only the outer runner's retry counter.
+If a requested branch base is called 'main' but the snapshot has only 'master', inspect the intended
+base commit. When 'master' names that same commit and the ref spelling itself is not required, use
+the existing ref as start_ref in a lifecycle plan and disclose the substitution. Do not ask for
+approval solely over a name; a genuinely different or unknown base needs a decision.
 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.
@@ -215,6 +222,11 @@ ${profileAgent(profile, "dog-worker")} task verbatim, in foreground. V2 maps sub
 task_id to sessionID. Do not insert model overrides unless the user explicitly selected them.
 
 After each Worker returns, use its actual report and host evidence. Continue pending units with operator_next.
+If a Worker returns process-defect with no formal validation evidence, inspect the specific missing
+execution/proof route before any new dispatch. A command run through a custom container tool is not
+native shell validation merely because its own output says PASS. If that route is unchanged, report
+the blocker to Operator instead of creating another run or Worker with the same defect. Correct a
+recoverable route within the current request and budget; this is not a new approval requirement.
 If plan_units returns mission-source-reconciliation-required, do not retry the same plan. The
 root-only Operator must reconcile the prior cancelled run. Submit status=blocked with the saved
 requirements and exact host diagnostic, then return; do not declare a user-only decision when
@@ -304,6 +316,12 @@ Use ${profile.toolPrefix}operator_status when the task needs native runtime iden
 remaining budget. It is a read-only observation available to Worker; do not request a separate unit or
 Coordinator transcription just to obtain it. It does not grant plan, dispatch or completion authority.
 
+If the requested new branch is from 'main' but this source snapshot has only the checked-out
+default 'master' at the intended base commit, use that existing ref as the branch base when the
+ref spelling itself is not required. Report the substitution, not a user-only decision. If the
+base commit differs or cannot be identified, report the ambiguity. Do not bypass a host Git
+lifecycle, rewrite history or alter an existing branch.
+
 Read/search and read-only investigation commands are unrestricted. Use targeted reproduction/diagnosis
 without registering every exploratory command. All writes, generated/transient files and cleanup stay
 inside the unit's file/directory scopes, except the tool environment below. Do not write outside them through

package/package.json

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