sortie-dogs 0.10.12 → 0.10.13

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";
 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";

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);
@@ -1407,6 +1408,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 +1663,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 +1738,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
@@ -736,7 +739,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.13",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",