sortie-dogs 0.10.12 → 0.10.14

package/README.md

@@ -50,7 +50,7 @@ two-level subagent depth to `.opencode/opencode.json`, preserving existing value
 ```json
 {
   "plugins": ["sortie-dogs"],
-  "subagent_depth": 2
+  "experimental": { "subagent_depth": 2 }
 }
 ```
 
@@ -302,7 +302,7 @@ npm install --global sortie-dogs
 sortie-dogs init --global --profile v010
 ```
 
-Then add `sortie-dogs` and `subagent_depth: 2` to the global OpenCode config.
+Then add `sortie-dogs` and `experimental.subagent_depth: 2` to the global OpenCode config.
 Global initialization installs assets only; it does not silently change the
 default agent or merge user settings.
 

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.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1";
 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.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1";
+export const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1";

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

@@ -303,6 +303,7 @@ export declare class OperatorRuntime {
     observeChild(root: string, callID: string, childID: string): Promise<void>;
     private observeChildOnce;
     operatorReturned(root: string): Promise<OperatorState>;
+    processReplacementRequired(root: string, runID: string): Promise<OperatorState>;
     private operatorReturnedOnce;
     interrupted(root: string, reason: string): Promise<readonly string[]>;
     private interruptedOnce;

package/dist/core/operator-runtime.js

@@ -29,6 +29,7 @@ export class OperatorContractError extends Error {
 const OPERATOR_TASK_REFERENCE = "SORTIE_OPERATOR_TASK_REF";
 const OPERATOR_DELEGATE_TASK_REFERENCE = "SORTIE_OPERATOR_DELEGATE_REF";
 const REPAIR_VALIDATION_STALE_PROOF_DECISION = "operator-contract-repair-validation-incomplete:operator-recovery-proof-unavailable-or-stale";
+const PROCESS_REPLACEMENT_DECISION = "operator-process-remediation-replacement-required";
 const ACCEPTANCE_REMEDIATION_DECISION = "operator-acceptance-remediation-required";
 const REVIEW_REMEDIATION_DECISION = "operator-review-remediation-required";
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -739,7 +740,7 @@ export class OperatorRuntime {
                     [ACCEPTANCE_CONTINUITY_EXTENSION]: { schema_version: "0.1", authority: "dispatch", task_id: taskID,
                         criteria: plan.acceptance, fingerprint: acceptanceFingerprint,
                         parent_fingerprint: index === 0
-                            ? remediationTaskID !== undefined && priorAcceptedUnits.length === 0 ? "none" : parent?.acceptanceFingerprint ?? "none"
+                            ? priorAcceptedUnits.length === 0 ? "none" : parent?.acceptanceFingerprint ?? "none"
                             : acceptanceFingerprint },
                     "sortie-dogs/unit-coverage": { schema_version: "0.1", task_id: taskID,
                         acceptance_fingerprint: acceptanceFingerprint, indices: unit.acceptance_indices },
@@ -980,7 +981,10 @@ export class OperatorRuntime {
     }
     matchesRecordedWorkerTask(state, unitID, args) {
         const unit = state.units.find(item => item.unit.id === unitID);
-        return unit !== undefined && this.matchesWorkerTask(state, unit, args);
+        const normalized = record(args) && typeof args.agent === "string" && args.subagent_type === undefined
+            ? { ...args, subagent_type: args.agent }
+            : args;
+        return unit !== undefined && this.matchesWorkerTask(state, unit, normalized);
     }
     admitOperator(root, callID, args) {
         return this.serial(root, () => this.admitOperatorOnce(root, callID, args));
@@ -1407,6 +1411,17 @@ export class OperatorRuntime {
     operatorReturned(root) {
         return this.serial(root, () => this.operatorReturnedOnce(root));
     }
+    processReplacementRequired(root, runID) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.decision !== "process-defect") {
+                throw new Error("operator-process-remediation-replacement-not-ready");
+            }
+            state.decision = PROCESS_REPLACEMENT_DECISION;
+            await this.save(state);
+            return state;
+        });
+    }
     async operatorReturnedOnce(root) {
         const state = await this.required(root);
         if (state.phase === "running") {
@@ -1651,8 +1666,9 @@ export class OperatorRuntime {
         const repairValidationRetryAvailable = this.canRetryRepairValidation(state);
         const acceptanceRemediation = state.decision === ACCEPTANCE_REMEDIATION_DECISION;
         const reviewRemediation = state.decision === REVIEW_REMEDIATION_DECISION;
+        const processReplacement = state.decision === PROCESS_REPLACEMENT_DECISION;
         const hostReconciliationRequired = state.phase === "awaiting-decision" && state.contractRepair === null &&
-            !repairValidationRetryAvailable && !acceptanceRemediation && !reviewRemediation;
+            !repairValidationRetryAvailable && !acceptanceRemediation && !reviewRemediation && !processReplacement;
         const failedAcceptanceUnit = acceptanceRemediation
             ? state.units.find(unit => unit.status === "failed" && ["acceptance", "process-defect"].includes(unit.resultClass ?? "")) : undefined;
         const failedEvidence = failedAcceptanceUnit?.failure;
@@ -1725,6 +1741,9 @@ export class OperatorRuntime {
             ...(hostReconciliationRequired ? {
                 next_action: `call ${this.profile.toolPrefix}resume_operator once with this run_id and acceptance_fingerprint; if it returns a Task, dispatch that exact Task in this turn`,
             } : {}),
+            ...(processReplacement ? {
+                next_action: `this immutable run is not resumable: call ${this.profile.toolPrefix}cancel_operator with reason=plain, then call ${this.profile.toolPrefix}prepare_operator for a replacement run under the same goal; copy this packet's acceptance array verbatim, retain consumed cumulative budget, and repair only the read, write, preparation, and validation contract required by that acceptance; do not call resume_operator again or claim evidence`,
+            } : {}),
             ...(acceptanceRemediation || reviewRemediation ? { next_action: remediationNextAction } : {}),
             ...(state.repairResidualPaths.length === 0 ? {} : { repair_residual_paths: state.repairResidualPaths }),
             ...(state.phase === "cancelled" && state.decision === "operator-contract-repair-unavailable-after-cancel" &&

package/dist/plugin/profiled.d.ts

@@ -4,6 +4,9 @@ import { type CatalogModel } from "./model-routing.js";
 export declare function processRemediationReplacementPacket(code: string, packet: unknown, cancelTool: string, prepareTool: string): {
     status: string;
     code: string;
+    same_run_resumable: boolean;
+    replacement_preserves_goal: boolean;
+    cumulative_spend_resets: boolean;
     packet: unknown;
     next_action: string;
 };

package/dist/plugin/profiled.js

@@ -39,10 +39,13 @@ const PREVIEW_ROUTES = Object.freeze([
     PREVIEW_REVIEW_ROUTE,
 ]);
 export function processRemediationReplacementPacket(code, packet, cancelTool, prepareTool) {
-    return { status: "operator-process-remediation-replacement-required", code, packet,
-        next_action: `Call ${cancelTool} with reason=plain, then call ${prepareTool} with the exact same ordered acceptance, ` +
-            "the same unit and write scope, and the remaining cumulative budget. Do not call resume_operator again, " +
-            "claim evidence, reset spend, or widen scope." };
+    const durable = record(packet) ? { ...packet, resume_requires_host_reconciliation: false,
+        next_action: `This immutable run is not resumable. Call ${cancelTool} with reason=plain, then call ${prepareTool} for a replacement run under the same goal.` } : packet;
+    return { status: "operator-process-remediation-replacement-required", code, same_run_resumable: false,
+        replacement_preserves_goal: true, cumulative_spend_resets: false, packet: durable,
+        next_action: `Call ${cancelTool} with reason=plain, then call ${prepareTool} for a replacement run under the same goal. ` +
+            "Copy the packet acceptance array byte-for-byte and retain cumulative spend. Repair only the read, write, preparation, and validation contract required by that acceptance. " +
+            "Do not call resume_operator again, claim evidence, or treat the replacement as a new goal." };
 }
 /**
  * Declare every preview route in the catalog, adding the variant to a listed model and the whole model
@@ -570,10 +573,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (requestedReason !== undefined && requestedReason !== "review-blocking" && requestedReason !== "acceptance-remediation")
                     throw new Error("operator-cancel-reason-invalid");
                 const pending = await operators.read(context.sessionID);
-                if (!pending) {
+                const pendingProposal = await proposals.read(context.sessionID);
+                if (!pending || (["cancelled", "completed"].includes(pending.phase) && pendingProposal?.phase !== "approved" && pendingProposal !== undefined)) {
                     // A pre-approval proposal owns no execution lane. Its admitted child can never be rebound, so without
                     // this release the root can neither resume, redispatch, nor start any replacement investigation.
-                    const proposal = await proposals.read(context.sessionID);
+                    const proposal = pendingProposal;
                     if (!proposal || proposal.phase === "approved")
                         throw new Error("operator-run-missing");
                     if (requestedReason !== undefined)
@@ -704,7 +708,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     if (unit.resultClass === "process-defect" && unit.childSessionID === null && unit.callID && state.decision === "dispatch-admission-rejected") {
                         const history = await messages(state.units.length > 1 ? delegate : context.sessionID);
                         const matching = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) &&
-                            part.type === "tool" && part.tool === "task" && part.callID === unit.callID && record(part.state) && part.state.status === "error" &&
+                            part.type === "tool" && ["task", "subagent"].includes(String(part.tool)) && part.callID === unit.callID && record(part.state) && part.state.status === "error" &&
                             record(part.state.input) && operators.matchesRecordedWorkerTask(state, unit.unit.id, part.state.input) &&
                             taskChildSessionID({ metadata: part.state.metadata, output: typeof part.state.output === "string" ? part.state.output : "" }) === undefined);
                         if (matching.length !== 1 || !await control.hasNoGoalReservation(context.sessionID, taskID, unit.callID))
@@ -736,7 +740,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                                 // A process defect without an authorized Git lifecycle has no committed remediation
                                 // baseline. Preserve the failed run and return an explicit replacement route instead
                                 // of turning this local routing limitation into a terminal tool exception.
-                                return JSON.stringify(processRemediationReplacementPacket(remediationError.message, operators.packet(state), cancel, prepare));
+                                const replacement = await operators.processReplacementRequired(context.sessionID, state.runID);
+                                return JSON.stringify(processRemediationReplacementPacket(remediationError.message, operators.packet(replacement), cancel, prepare));
                             }
                         }
                         const retried = await operators.resumeRepairValidation(context.sessionID, state.runID, source => control.authorizeOperatorContractRepairValidationRetry(context.sessionID, { ...source, declarationFingerprint: goalFingerprint }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",
@@ -62,14 +62,13 @@
     "build": "tsc -p tsconfig.json",
     "postbuild": "node --input-type=module --eval \"import fs from 'node:fs'; const path = 'dist/cli/main.js'; const source = fs.readFileSync(path, 'utf8'); if (!source.startsWith('#!')) fs.writeFileSync(path, '#!/usr/bin/env node\\n' + source); if (process.platform !== 'win32') fs.chmodSync(path, 0o755);\"",
     "prepack": "npm run build",
-    "pretest": "npm run build",
-    "test": "node --experimental-strip-types --import ./test/setup.ts --test \"test/plugin.test.ts\" \"test/continuation.test.ts\" \"test/fast-lane.test.ts\"",
+    "test": "node scripts/test-router.mjs quick",
+    "test:windows": "node scripts/test-router.mjs windows",
     "pretest:dispatch": "npm run build",
     "test:dispatch": "node --experimental-strip-types --import ./test/setup.ts --test --test-timeout=100000 --test-reporter=spec \"test/execution-plan.test.ts\" \"test/worktree-parallel-dispatch.test.ts\" \"test/acceptance-compiler.test.ts\" \"test/run-flight-ledger.test.ts\" \"test/evidence-capsule.test.ts\"",
     "pretest:integration": "npm run build",
     "test:integration": "node --experimental-strip-types --import ./test/setup.ts --test --test-timeout=1200000 --test-reporter=spec \"test/integration/worktree-parallel-dispatch.test.ts\"",
-    "pretest:full": "npm run build",
-    "test:full": "node --experimental-strip-types test/helpers/full-test-runner.ts"
+    "test:full": "node scripts/test-router.mjs full"
   },
   "dependencies": {
     "ajv": "^8.17.1",