sortie-dogs 0.12.20 → 0.12.21

package/README.md

@@ -97,6 +97,8 @@ Official SWE-bench Lite `dev` results on the same 23 public instances:
 | v0.12.8 (`84ccdf1` main adapter) | 6 / 23 (26.1%) | 2 | Fresh 23-task run; four slots; 30-minute timeout | [Main-integrated run](docs/swebench-main-84ccdf1-dev23-2026-09-26.md) |
 | v0.12.15 (`0c9690d`) | 5 / 23 (21.7%) | 3 | Fresh 23-task ext4 retry; four slots; 40-minute timeout | [Campaign](docs/swebench-v01215-dev23-2026-09-27.md) |
 | v0.12.16 (`9b05a34` release; `b1a6c0e` runner) | 4 / 23 (17.4%) | 5 | Fresh 23-task run; eight slots; 40-minute timeout | [Campaign](docs/swebench-v01216-dev23-2026-09-27.md) |
+| v0.12.19 (`24f5386` release; matched rerun) | 8 / 23 (34.8%) | 0 | Eight slots; effective $2/instance; 40-minute timeout; one inference timeout | [Official result and provenance](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
+| v0.12.20 (`628eb81` release) | 7 / 23 (30.4%) | 0 | Eight slots; effective $2/instance; 40-minute timeout | [Official result and caveat](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
 
 Every row has 23 submitted official predictions; an empty patch counts against
 the score, not as a missing evaluation. The v0.10.14 report does not separately
@@ -110,6 +112,11 @@ estimated $15.75 in model cost and a 15.2-minute median agent runtime.
 The v0.12.16 run is the first eight-slot inference score in this table;
 five runners timed out, and this does not establish a model-quality regression
 against runs with different concurrency and conditions.
+The v0.12.19 row is the corrected run with an effective $2 per-instance cap;
+an earlier v0.12.19 run scored 7/23 but had no effective per-instance cap and
+is not a same-condition comparison. The v0.12.20 run lost the
+`sqlfluff__sqlfluff-2419` resolution relative to the corrected run; this
+single run-to-run difference does not establish causation.
 
 Historical qualification references remain in [benchmark reference](docs/benchmark-reference.md).
 

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.20-mission-recovery-rescue-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.21-validation-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.20-mission-recovery-rescue-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.21-validation-recovery-v1";

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 { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot } from "./protected-snapshot.js";
+import { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot, validationInputSnapshot } 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 };
@@ -1481,11 +1481,14 @@ export const SortieDogsPlugin = async (input, options) => {
         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;
+        const validationInputs = validation !== undefined && operationInputs === undefined
+            ? await validationInputSnapshot(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 }),
+            ...(validationInputs === undefined ? {} : { validationInputs }),
             owner: validation?.request.owner ?? "worker", validation,
             ...(reusedEvidence === undefined ? {} : { reusedEvidence }) });
     }
@@ -1513,11 +1516,13 @@ 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();
-        // 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);
+        // Declared outputs can change during a successful validation. Read inputs must not;
+        // the evidence still binds to the complete post-command candidate and source.
+        const fresh = refreshed !== undefined && (execution.operationInputs !== undefined
+            ? await operationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.operationInputs
+            : execution.validationInputs !== undefined
+                ? await validationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.validationInputs
+                : refreshed.source === execution.source);
         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,
@@ -7528,8 +7533,17 @@ export const SortieDogsPlugin = async (input, options) => {
                 return { status: "unproven", reservation_id: reservation.reservation_id, reason: "owned-native-lineage-unavailable" };
             }
             const sessionAPI = input.client.session;
+            // V2's session.context is bounded. The aborted parent Task can be days older than
+            // that window; use the owning service's paginated history when the adapter offers it.
+            const historyAPI = sessionAPI;
+            const readHistory = historyAPI.reviewMessages ?? sessionAPI.messages;
             const messages = async (id) => {
-                const response = await sessionAPI.messages({ path: { id }, query: { directory: input.directory } });
+                const request = { path: { id }, query: { directory: input.directory } };
+                const response = await readHistory.call(sessionAPI, request).catch(error => {
+                    if (readHistory === sessionAPI.messages)
+                        throw error;
+                    return sessionAPI.messages(request);
+                });
                 return isRecord(response) && Array.isArray(response.data) ? response.data.filter(isRecord) : [];
             };
             const children = async (id) => {

package/dist/plugin/profiled.js

@@ -1697,7 +1697,18 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!reason?.trim())
                     throw new Error("mission-replan-reason-required: name the observed correction or write-scope extension");
             }
-            const budget = await control.currentBudget(root);
+            // A cancelled V2 delegate may leave its Worker Task running after the parent Task aborts.
+            // Reconcile that exact native orphan before checking the cumulative budget or replacing
+            // the run; an unproven orphan remains reserved and the normal terminal check still blocks.
+            const cancelledPredecessor = previous?.phase === "cancelled" &&
+                (mission.supersededRunID === previous.runID ||
+                    (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
+                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
+            let budget = await control.currentBudget(root);
+            if (cancelledPredecessor && budget?.reserved_units) {
+                await control.reconcileAbortedOperatorOrphan(root);
+                budget = await control.currentBudget(root);
+            }
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error(`mission-budget-exhausted: plan needs ${plan.units.length} units; ${budget.remaining_units} remain. ` +
                     "The current run is retained. Correct the plan within the remaining budget, or report a necessary cumulative extension to Operator.");
@@ -1708,10 +1719,6 @@ export function createProfiledPlugin(profile, assetVersion) {
             }
             // Cancellation marks the durable units before interrupting their native sessions. A cancelled
             // status alone therefore cannot prove the old Worker stopped or its reservation settled.
-            const cancelledPredecessor = previous?.phase === "cancelled" &&
-                (mission.supersededRunID === previous.runID ||
-                    (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
-                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
             const terminalChildren = cancelledPredecessor
                 ? await terminalCancelledMissionChildren(profile, root, previous, budget, {
                     get: async (id) => {
@@ -2350,6 +2357,20 @@ export function createProfiledPlugin(profile, assetVersion) {
                             }
                         }
                     }
+                    const operationArgs = record(mapped.args) ? mapped.args : {};
+                    // A decorated launch would spend on the real operation but leave the native mission observation empty.
+                    // Ask the same Worker to correct its shell input before that expensive side effect.
+                    if (who.role === "dog-worker" && ["bash", "shell"].includes(request.tool.toLowerCase()) && mission?.execution &&
+                        typeof operationArgs.command === "string" &&
+                        resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : ".") === mission.execution.directory) {
+                        const actual = normalizeCommand(operationArgs.command);
+                        const decorated = mission.execution.commands.some(declared => actual.startsWith(declared) &&
+                            /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(declared.length)));
+                        if (decorated)
+                            throw new Error("mission-operation-command-not-observed: run the declared operation command exactly; " +
+                                "do not append a pipe, tee, redirection or chained command. Capture its tool output or write a separate result file afterward. " +
+                                "No new plan or approval is needed; if the run already started, inspect its existing state instead of starting another one.");
+                    }
                     await core["tool.execute.before"]?.({ ...translate(request, false),
                         ...(delegated ? { sessionID: root, agent: "dog-coordinator" } : {}) }, mapped);
                     if (who.role === "dog-worker") {

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

@@ -5,6 +5,9 @@ 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>;
+/** A validation may populate write-only caches. Keep its declared read inputs stable
+ * while binding the resulting candidate (including those outputs) after the command. */
+export declare function validationInputSnapshot(projectRoot: string, binding: Binding): Promise<string | undefined>;
 export declare function protectedSnapshot(authorization: {
     manifestPath: string;
     manifestHash: string;

package/dist/plugin/protected-snapshot.js

@@ -86,6 +86,24 @@ export async function operationInputSnapshot(projectRoot, binding) {
         ? await declaredScopeDigest(projectRoot, paths, hash, true, outputs)
         : await protectedScopeDigest(projectRoot, paths, hash, binding.source_policy, outputs);
 }
+/** A validation may populate write-only caches. Keep its declared read inputs stable
+ * while binding the resulting candidate (including those outputs) after the command. */
+export async function validationInputSnapshot(projectRoot, binding) {
+    const manifestSource = await readFile(resolve(projectRoot, binding.manifest_path)).catch(() => undefined);
+    if (!manifestSource || `sha256:${createHash("sha256").update(manifestSource).digest("hex")}` !== binding.manifest_hash)
+        return undefined;
+    const manifest = JSON.parse(manifestSource.toString("utf8"));
+    if (!manifest.read.length)
+        return undefined; // Keep the original full-source check when no inputs were declared.
+    const paths = manifest.read.map(entry => {
+        const path = normalizeManifestScope(entry);
+        return path.kind === "relative" ? resolve(projectRoot, path.path) : resolve(path.path);
+    });
+    const hash = binding.manifest_hash.slice("sha256:".length);
+    return binding.source_policy === "declared-paths-v1"
+        ? declaredScopeDigest(projectRoot, paths, hash, true)
+        : protectedScopeDigest(projectRoot, paths, hash, binding.source_policy);
+}
 export async function protectedSnapshot(authorization) {
     const manifestSource = await readFile(authorization.manifestPath).catch(() => undefined);
     if (manifestSource === undefined)

package/dist/runtime-mission-assets.js

@@ -13,6 +13,13 @@ For tag observation use git tag --points-at <commit>. For HTTPS downloads use cu
 --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.
+Before launching a detached operation, verify supported options and budget from the CLI/preflight;
+a preview is not the live run. Check the actual state after launch, before relying on its limits.
+Run each declared execution command as the exact native shell input; do not append a tee pipeline,
+redirection or wrapper that was not declared. The host observes that command, not a nearby script or result file.
+Save its output separately when needed. A successful launch only proves the process started;
+use that same run's terminal state and official result for completion, never launch it again
+to repair a missing observation.
 `;
 function controls(profile, names) {
     return names.map(name => `  ${profile.toolPrefix}${name}: true`).join("\n");
@@ -88,6 +95,8 @@ results to guide the following units. Do not invent preparation units or plan-ap
 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.
+Do not turn a chosen preflight step into a user requirement that the live run's state exists before launch.
+Observe supported flags and budget before launch, then observe the real state immediately after launch.
 Use requirement_ids when splitting multiple requirements across units; a single unit inherits all requirements
 when they are omitted. These are related requirements,
 not claims that a command proves every semantic obligation. Compare the final result yourself.
@@ -255,6 +264,8 @@ it with sharper traces and evidence: [{path, offset, limit}] from the existing o
   Declared external input/output excerpts remain available. 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.
+Evaluating an unchanged published package is not a release or source edit: use the native execution,
+result and hash records rather than adding an independent source-review round solely for its label.
 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.20",
+  "version": "0.12.21",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",