sortie-dogs 0.13.19 → 0.13.20

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.13.19](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.19)**
-· [Release notes](docs/release-v0.13.19.md)
+**Current release: [v0.13.20](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.20)**
+· [Release notes](docs/release-v0.13.20.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -57,7 +57,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.19
+npm install --save-dev sortie-dogs@0.13.20
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -86,7 +86,7 @@ bridge. [Codex guide: SDK, permissions, progress, resume and manifest route](doc
 Use **OpenCode V2**. In the target project:
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.19
+npm install --save-dev sortie-dogs@0.13.20
 npx --no-install sortie-dogs init .
 ```
 
@@ -193,7 +193,7 @@ known expense. Official local evaluation and leaderboard acceptance are separate
 **8/23 (34.8%)**, versus v0.12.25's 7/23; all seven prior resolutions retained, no empty patches or
 official evaluation errors. [Fixed conditions, stopped-run accounting and costs](docs/benchmarks/swebench-lite-history.md#v0131-dev23-2026-09-30).
 
-All scores belong to their fixed candidates, **not v0.13.19**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.20**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -216,7 +216,7 @@ Install the desired package version and rerun **your host's** initializer:
 
 An OpenCode config-local bridge may resolve a separate package; npm-global update alone does not
 update it. [Global/update instructions](docs/configuration.md#global-availability).
-The current Mission asset marker is `0.13.19-workload-progress-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.20-review-followup-v1`; the unchanged Codex skill marker is
 `0.13.11-codex-skill-v2`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -232,7 +232,7 @@ follow the [manual removal guide](docs/uninstall.md), never delete the entire `.
   [SWE-bench history](docs/benchmarks/swebench-lite-history.md) · [Historical local case study](docs/benchmark-reference.md).
 - **Development:** [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md) ·
   [Windows tests](docs/windows-tests.md) · [Release routine](docs/release-batch.md).
-- **Releases:** [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
+- **Releases:** [v0.13.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
   [v0.13.9](docs/release-v0.13.9.md) · [All GitHub releases](https://github.com/zufall-upon/Sortie-dogs/releases).
 
 ## Community

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * 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.13.19-workload-progress-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.20-review-followup-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * 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.13.19-workload-progress-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.20-review-followup-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/core/work-quantity-observations.d.ts

@@ -2,6 +2,10 @@
 import type { OperatorMission } from "./operator-mission.js";
 import type { OperatorState } from "./operator-runtime.js";
 import { type WorkQuantityEvent, type WorkQuantityState, type WorkQuantityProgress } from "./work-quantity.js";
+export declare function forgetWorkSession(directory: string, actor: string): void;
+export declare function forgetWorkDirectory(directory: string): void;
+/** Module-global observations remain live until the last overlapping Location setup unloads. */
+export declare function retainWorkDirectory(directory: string): () => void;
 export declare function rememberWorkMission(directory: string, mission: OperatorMission): void;
 export declare function rememberWorkRun(directory: string, run: OperatorState): void;
 export declare function rememberedWorkRun(directory: string, root: string): OperatorState | undefined;

package/dist/core/work-quantity-observations.js

@@ -1,12 +1,74 @@
 import { observeWorkQuantity, planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
 const views = new Map();
 const owners = new Map();
+const instances = new Map();
+// Terminal UI snapshots contain no Mission/run/events and cannot grow with history.
+const terminals = new Map();
 const identity = (directory, root) => `${directory.replaceAll("\\", "/").replace(/\/$/u, "")}\0${root}`;
+function forgetRoot(directory, root) {
+    const id = identity(directory, root), prefix = identity(directory, "");
+    views.delete(id);
+    terminals.delete(id);
+    for (const [actor, owner] of owners)
+        if (actor.startsWith(prefix) && owner === root)
+            owners.delete(actor);
+}
+export function forgetWorkSession(directory, actor) {
+    const id = identity(directory, actor);
+    if (views.has(id) || terminals.has(id) || owners.get(id) === actor)
+        forgetRoot(directory, actor);
+    else {
+        const root = owners.get(id);
+        if (root)
+            views.get(identity(directory, root))?.deleted.add(actor);
+        owners.delete(id);
+    }
+}
+export function forgetWorkDirectory(directory) {
+    const prefix = identity(directory, "");
+    for (const cache of [views, owners, terminals])
+        for (const id of cache.keys())
+            if (id.startsWith(prefix))
+                cache.delete(id);
+}
+/** Module-global observations remain live until the last overlapping Location setup unloads. */
+export function retainWorkDirectory(directory) {
+    const id = identity(directory, "");
+    instances.set(id, (instances.get(id) ?? 0) + 1);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const remaining = (instances.get(id) ?? 1) - 1;
+        if (remaining)
+            instances.set(id, remaining);
+        else {
+            instances.delete(id);
+            forgetWorkDirectory(directory);
+        }
+    };
+}
+function own(directory, root, actor, value) {
+    if (!value.deleted.has(actor))
+        owners.set(identity(directory, actor), root);
+}
+function finishView(directory, root, value) {
+    const mission = value.mission, run = value.run;
+    const progress = mission ? projectWorkQuantity(missionWorkState(directory, mission, run), mission.phase === "completed", mission.phase === "cancelled")
+        : run?.workQuantity ? projectWorkQuantity(syncWorkQuantity(applyPendingWork(directory, root, structuredClone(run.workQuantity)), {}, run), run.phase === "completed", run.phase === "cancelled") : undefined;
+    forgetRoot(directory, root);
+    if (progress)
+        terminals.set(identity(directory, root), { progress, runID: mission?.runID ?? run?.runID });
+    if (terminals.size > 128)
+        terminals.delete(terminals.keys().next().value);
+}
 function view(directory, root) {
     const id = identity(directory, root);
+    terminals.delete(id);
     let value = views.get(id);
     if (!value) {
-        value = { sequence: 0, events: new Map() };
+        value = { sequence: 0, events: new Map(), deleted: new Set() };
         views.set(id, value);
     }
     owners.set(id, root);
@@ -20,23 +82,30 @@ export function rememberWorkMission(directory, mission) {
     value.sequence = Math.max(value.sequence, mission.workQuantity?.observationSequence ?? 0);
     delete value.progress;
     if (mission.coordinator)
-        owners.set(identity(directory, mission.coordinator), mission.root);
+        own(directory, mission.root, mission.coordinator, value);
     if (mission.review?.child)
-        owners.set(identity(directory, mission.review.child), mission.root);
+        own(directory, mission.root, mission.review.child, value);
     for (const attempt of mission.attempts ?? [])
         if (attempt.childSessionID)
-            owners.set(identity(directory, attempt.childSessionID), mission.root);
+            own(directory, mission.root, attempt.childSessionID, value);
+    if (["completed", "cancelled"].includes(mission.phase))
+        finishView(directory, mission.root, value);
 }
 export function rememberWorkRun(directory, run) {
+    const terminal = terminals.get(identity(directory, run.rootSessionID));
+    if (terminal && terminal.runID === run.runID)
+        return;
     const value = view(directory, run.rootSessionID);
     value.run = run;
     value.sequence = Math.max(value.sequence, run.workQuantity?.observationSequence ?? 0);
     delete value.progress;
     if (run.operatorSessionID)
-        owners.set(identity(directory, run.operatorSessionID), run.rootSessionID);
+        own(directory, run.rootSessionID, run.operatorSessionID, value);
     for (const unit of run.units)
         if (unit.childSessionID)
-            owners.set(identity(directory, unit.childSessionID), run.rootSessionID);
+            own(directory, run.rootSessionID, unit.childSessionID, value);
+    if (!value.mission && ["completed", "cancelled"].includes(run.phase))
+        finishView(directory, run.rootSessionID, value);
 }
 export function rememberedWorkRun(directory, root) {
     return views.get(identity(directory, root))?.run;
@@ -77,6 +146,9 @@ export function missionWorkState(directory, mission, run) {
     return syncWorkQuantity(applyPendingWork(directory, mission.root, structuredClone(state)), mission, run);
 }
 export function cachedWorkProgress(directory, actor) {
+    const terminal = terminals.get(identity(directory, actor));
+    if (terminal)
+        return terminal.progress;
     const root = owners.get(identity(directory, actor));
     const value = root && views.get(identity(directory, root));
     if (!value)

package/dist/core/work-quantity.js

@@ -27,6 +27,7 @@ function pathMatches(actual, binding) {
     const a = key(actual), b = key(binding).replace(/\/\*\*$/u, "");
     return a === b || broad(binding) && ([".", "**"].includes(b) || a.startsWith(`${b}/`));
 }
+const pathsOverlap = (a, b) => pathMatches(a, b) || pathMatches(b, a);
 function fraction(item) {
     const o = item.observation;
     if (item.removed)
@@ -71,6 +72,10 @@ function item(id, kind, label, requirements, paths = [], commands = [], units =
     return { id, kind, label, requirementIDs: unique(requirements), weight: weight[kind], basis: "derived",
         paths: unique(paths.map(key)), commands: unique(commands.map(commandKey)), units: unique(units), observation: {}, fraction: 0 };
 }
+/** Keep alias observations for later subdivisions without counting their quantity twice. */
+function retainedAliases(state) {
+    return new Set(state.items.filter(entry => !entry.removed && entry.basis === "declared").flatMap(entry => entry.aliases ?? []));
+}
 /** Concrete work before scheduling/coalescence; broad scopes remain unexpanded estimates. */
 export function planWorkQuantity(mission, rawUnits = [], run, previous, declared, directory) {
     const pathKey = (path) => {
@@ -198,7 +203,7 @@ export function planWorkQuantity(mission, rawUnits = [], run, previous, declared
         if (units.length)
             declared.units = units;
         for (const child of state.items.filter(entry => entry.parentID === declared.id && !entry.removed)) {
-            const matched = aliases.filter(entry => !child.paths.length && !child.commands.length || entry.paths.some(path => child.paths.includes(path)) ||
+            const matched = aliases.filter(entry => !child.paths.length && !child.commands.length || entry.paths.some(path => child.paths.some(binding => pathsOverlap(path, binding))) ||
                 entry.commands.some(command => child.commands.includes(command)));
             const units = unique(matched.flatMap(entry => entry.units));
             if (units.length)
@@ -282,8 +287,37 @@ function applyDeclaredWork(state, raw, generated, pathKey) {
                     child.units = parent.units;
                     child.paths = strings(point.paths).map(pathKey);
                     child.commands = strings(point.commands).map(commandKey);
-                    if (!state.items.includes(child))
-                        child.observation = { ...parent.observation };
+                    if (!state.items.includes(child)) {
+                        const aliases = matches.filter(alias => child.paths.some(path => alias.paths.some(binding => pathsOverlap(path, binding))) ||
+                            child.commands.some(command => alias.commands.includes(command)));
+                        const observations = aliases.map(alias => {
+                            const saved = state.items.find(entry => entry.id === alias.id).observation;
+                            if (!alias.targetEstimate || child.paths.some(path => alias.paths.includes(path)))
+                                return saved;
+                            const projected = { ...saved };
+                            // A broad alias's changed-target list identifies concrete edits;
+                            // its scalar read flag does not identify which child was read.
+                            delete projected.read;
+                            if (saved.changed) {
+                                projected.changedTargets = (saved.changedTargets ?? []).filter(path => child.paths.some(binding => pathMatches(path, binding)));
+                                projected.changed = projected.changedTargets.length > 0;
+                            }
+                            return projected;
+                        });
+                        // Bound checkpoints inherit only matching aliases. Multiple aliases retain
+                        // common observations conservatively; an unbound checkpoint covers its parent.
+                        child.observation = !child.paths.length && !child.commands.length ? { ...parent.observation }
+                            : Object.fromEntries(Object.entries(observations[0] ?? {}).filter(([field, value]) => observations.every(observation => JSON.stringify(observation[field]) === JSON.stringify(value))));
+                        if (child.paths.some(broad) && aliases.length && aliases.every(alias => !alias.targetEstimate && alias.paths.length)) {
+                            const targets = unique(aliases.flatMap(alias => alias.paths).filter(path => child.paths.some(binding => pathMatches(path, binding))));
+                            child.targetEstimate = targets.length;
+                            child.observation.changedTargets = unique(aliases.flatMap((alias, i) => observations[i].changed ? alias.paths : [])
+                                .filter(path => targets.includes(path)));
+                            child.observation.changed = child.observation.changedTargets.length > 0;
+                            if (observations.some(observation => observation.read))
+                                child.observation.read = true;
+                        }
+                    }
                     child.parentID = parent.id;
                     child.weight = amount * quantities[index] / sum;
                     child.basis = "declared";
@@ -309,8 +343,9 @@ export function observeWorkQuantity(state, event) {
                 state.revisionReason = "native work revealed an additional target";
             }
     }
+    const aliases = retainedAliases(state);
     for (const entry of state.items) {
-        if (entry.removed || entry.children?.length)
+        if (entry.removed && !aliases.has(entry.id) || entry.children?.length)
             continue;
         const pathMatch = paths.some(path => entry.paths.some(binding => pathMatches(path, binding)));
         const unitMatch = event.unit !== undefined && entry.units.includes(event.unit);
@@ -373,8 +408,9 @@ export function syncWorkQuantity(state, mission, run) {
         state.lastReview = reviewRef;
     else
         delete state.lastReview;
+    const aliases = retainedAliases(state);
     for (const entry of state.items) {
-        if (entry.removed || entry.children?.length)
+        if (entry.removed && !aliases.has(entry.id) || entry.children?.length)
             continue;
         const units = current?.units.filter(unit => entry.units.includes(`${current.runID}/${unit.unit.id}`)) ?? [];
         if (["artifact", "implementation", "validation", "requirement"].includes(entry.kind) && units.length && units.every(unit => unit.status === "succeeded")) {

package/dist/plugin/profiled.js

@@ -16,7 +16,7 @@ import { normalizeExecutionScope, normalizeManifestScope, normalizeRelativePath
 import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionStatus, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
 import { formatWorkQuantity, planWorkQuantity } from "../core/work-quantity.js";
-import { cachedWorkProgress, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
+import { cachedWorkProgress, forgetWorkSession, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
 import { serializeOperatorStatus } from "./operator-status-output.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionDeliveryObservation, missionReviewBaseline, missionReviewSource, observedMissionValidation, observedMissionValidationSummary, missionReviewValidation, reviewerCorrectionValidation, reviewerCorrectionValidationFresh, validationDirectoryMatches } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
@@ -551,7 +551,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // not by resetting the goal budget. This checkpoint grants no dispatch itself.
                 if (mission && (!["completed", "cancelled"].includes(mission.phase) ||
                     (mission.phase === "cancelled" && run))) {
-                    return JSON.stringify(missionPacket(mission, run));
+                    return JSON.stringify(missionPacket(mission, run, false));
                 }
                 return await operators.continuationCheckpoint(root) ?? await proposals.continuationCheckpoint(root);
             },
@@ -4489,42 +4489,48 @@ export function createProfiledPlugin(profile, assetVersion) {
                             : event.type.startsWith("session.") && typeof info?.id === "string" ? info.id : undefined;
                 if (!id)
                     return;
-                if (event.type === "session.deleted" && canonicalAgent(profile, selected.get(id)) === "dog-coordinator") {
-                    await stop(id, "session-deleted");
-                    return;
-                }
-                if (!await rootFor(id))
-                    return;
-                const mappedEvent = translate({ event }, false);
-                const mappedPart = record(mappedEvent.event.properties?.part) ? mappedEvent.event.properties.part : undefined;
-                if ((await identity(id)).role === "dog-coordinator" && mappedPart?.type === "text" && typeof mappedPart.text === "string") {
-                    mappedPart.text = forwardTerminalText(mappedPart.text);
-                }
-                await core.event?.(mappedEvent);
-                if (event.type === "message.updated" && info)
-                    await renderCompletedReply(id, info);
-                if (event.type === "message.part.updated" && part?.type === "tool" && part.tool === "task" &&
-                    typeof part.callID === "string" && record(part.state) && part.state.status === "error") {
-                    const ownership = taskOwners.get(part.callID);
-                    if (ownership !== undefined && ownership.actor === id) {
-                        if (ownership.mission) {
-                            await missions.update(ownership.root, state => { state.dispatchOpen = false; });
-                            taskOwners.delete(part.callID);
-                            return;
-                        }
-                        if (ownership.consultation) {
-                            taskOwners.delete(part.callID);
-                            return;
+                try {
+                    if (event.type === "session.deleted" && canonicalAgent(profile, selected.get(id)) === "dog-coordinator") {
+                        await stop(id, "session-deleted");
+                        return;
+                    }
+                    if (!await rootFor(id))
+                        return;
+                    const mappedEvent = translate({ event }, false);
+                    const mappedPart = record(mappedEvent.event.properties?.part) ? mappedEvent.event.properties.part : undefined;
+                    if ((await identity(id)).role === "dog-coordinator" && mappedPart?.type === "text" && typeof mappedPart.text === "string") {
+                        mappedPart.text = forwardTerminalText(mappedPart.text);
+                    }
+                    await core.event?.(mappedEvent);
+                    if (event.type === "message.updated" && info)
+                        await renderCompletedReply(id, info);
+                    if (event.type === "message.part.updated" && part?.type === "tool" && part.tool === "task" &&
+                        typeof part.callID === "string" && record(part.state) && part.state.status === "error") {
+                        const ownership = taskOwners.get(part.callID);
+                        if (ownership !== undefined && ownership.actor === id) {
+                            if (ownership.mission) {
+                                await missions.update(ownership.root, state => { state.dispatchOpen = false; });
+                                taskOwners.delete(part.callID);
+                                return;
+                            }
+                            if (ownership.consultation) {
+                                taskOwners.delete(part.callID);
+                                return;
+                            }
+                            const settled = ownership.proposal
+                                ? (await control.settleProposalBudget(ownership.root, (await proposals.required(ownership.root)).intent_id, part.callID, "failed"), true)
+                                : ownership.operator
+                                    ? (await operators.operatorRejected(ownership.root), true)
+                                    : await control?.settleRejectedDispatch(ownership.root, part.callID) ?? false;
+                            if (settled)
+                                taskOwners.delete(part.callID);
                         }
-                        const settled = ownership.proposal
-                            ? (await control.settleProposalBudget(ownership.root, (await proposals.required(ownership.root)).intent_id, part.callID, "failed"), true)
-                            : ownership.operator
-                                ? (await operators.operatorRejected(ownership.root), true)
-                                : await control?.settleRejectedDispatch(ownership.root, part.callID) ?? false;
-                        if (settled)
-                            taskOwners.delete(part.callID);
                     }
                 }
+                finally {
+                    if (event.type === "session.deleted")
+                        forgetWorkSession(input.directory, id);
+                }
             },
         };
         const before = hooks["tool.execute.before"];

package/dist/plugin/v2.js

@@ -1,7 +1,7 @@
 import { toolSchema, legacyToolArgs } from "./tool-schema.js";
 import { SortieDogsV010Plugin } from "./profiled.js";
 import { bindMissionProgress, missionProgressReader } from "./mission-progress.js";
-import { cachedWorkProgress, workRootForActor } from "../core/work-quantity-observations.js";
+import { cachedWorkProgress, forgetWorkSession, retainWorkDirectory, workRootForActor } from "../core/work-quantity-observations.js";
 import { formatWorkQuantity } from "../core/work-quantity.js";
 import { owningServiceMessageList, owningServiceSessionList, owningServiceSessionActive } from "./v2-session-history.js";
 import { nativeContractReadSnapshot } from "./native-contract-read.js";
@@ -870,90 +870,103 @@ export function createSortieDogsV2Plugin(legacyFactory = SortieDogsV010Plugin) {
     return {
         id: "sortie-dogs.v010",
         async setup(context) {
-            let hooks;
-            const liveState = new Map();
-            const background = new NativeBackgroundLifecycle(context, async (dispatch, text) => {
-                if (dispatch.owner)
-                    hooks.backgroundOwner?.(dispatch.callID, dispatch.owner);
-                const output = { status: dispatch.terminal === "succeeded" ? "completed" : dispatch.terminal === "interrupted" ? "cancelled" : "error",
-                    output: text, metadata: { sessionID: dispatch.child, status: dispatch.terminal } };
-                await hooks["tool.execute.after"]?.({ tool: "task", sessionID: dispatch.parent, callID: dispatch.callID,
-                    args: legacyToolInput("subagent", dispatch.input) }, output);
-                if (dispatch.child)
-                    await syncReviewerCorrectionPermissions(context, hooks, dispatch.child);
-                // Inline Review already has a compact provenance receipt; retain the full diagnostic packet in its ordinary tool route.
-                try {
-                    const packet = JSON.parse(output.output);
-                    if (record(packet) && record(packet.completion_receipt))
-                        return JSON.stringify(packet.completion_receipt);
-                }
-                catch { /* Ordinary native outputs are not necessarily JSON. */ }
-                return output.output;
-            }, (callID, restore) => hooks.backgroundOwner?.(callID, restore), (parent, callID, child, promptID) => hooks.backgroundResult?.(parent, callID, child, promptID) ?? Promise.resolve(undefined));
-            hooks = await legacyFactory({ directory: context.location.directory, client: legacyClient(context),
-                nativeBackground: background, returnReportTransport: "tool-result",
-                reviewerCorrectionPermissions: !!context.agent && !!context.storage && !!context.session.switchAgent }, context.options ?? {});
-            await registerV2Hooks(context, hooks, background, liveState);
-            // Recreate exact durable correction profiles at plugin setup, before resumed native Steps
-            // resolve their agent/tool snapshots. Storage.scan is part of Plugin 2.0.18's public domain.
-            if (context.storage?.scan) {
-                let after;
-                do {
-                    const page = await context.storage.scan({ prefix: correctionStoragePrefix, ...(after ? { after } : {}) });
-                    for (const entry of page.entries)
-                        await syncReviewerCorrectionPermissions(context, hooks, entry.key.slice(correctionStoragePrefix.length));
-                    after = page.next;
-                } while (after);
-            }
-            const finalize = createV2ReturnReportFinalizer(context, hooks);
-            const controller = new AbortController();
-            const eventOperations = new Map();
-            const handleEvent = async (event) => {
-                const data = record(event.data) ? event.data : {};
-                const id = string(data.sessionID);
-                if (event.type === "filesystem.changed" && typeof data.file === "string") {
-                    await hooks.event?.({ event: { type: "file.edited", properties: { file: data.file } } });
-                    return;
-                }
-                if (id === undefined)
-                    return;
-                if (String(event.type).startsWith("session.execution.") || event.type === "session.inbox.enqueued" || event.type === "session.idle")
-                    await background.event(event);
-                if (event.type === "session.deleted") {
-                    await context.storage?.remove?.(childSelectionKey(id));
-                    liveState.delete(id);
-                    await context.storage?.remove?.(liveStateKey(id));
-                    // This native event is definite deletion, unlike a transient session.get failure.
-                    await disposeCorrectionPermissions(context, id);
-                }
-                if (event.type === "session.execution.succeeded")
-                    await finalize(id);
-                if (event.type === "session.created" || event.type === "session.deleted" || event.type === "session.idle") {
-                    const info = event.type === "session.created" ? await context.session.get({ sessionID: id }).catch(() => ({ id })) : { id };
-                    await hooks.event?.({ event: { type: String(event.type), properties: { sessionID: id, info } } });
-                    for (const child of await hooks.reviewerCorrectionSessions?.(id) ?? [])
-                        await syncReviewerCorrectionPermissions(context, hooks, child);
-                    if (event.type !== "session.deleted")
-                        await syncReviewerCorrectionPermissions(context, hooks, id);
+            const releaseWork = retainWorkDirectory(context.location.directory);
+            try {
+                let hooks;
+                const liveState = new Map();
+                const background = new NativeBackgroundLifecycle(context, async (dispatch, text) => {
+                    if (dispatch.owner)
+                        hooks.backgroundOwner?.(dispatch.callID, dispatch.owner);
+                    const output = { status: dispatch.terminal === "succeeded" ? "completed" : dispatch.terminal === "interrupted" ? "cancelled" : "error",
+                        output: text, metadata: { sessionID: dispatch.child, status: dispatch.terminal } };
+                    await hooks["tool.execute.after"]?.({ tool: "task", sessionID: dispatch.parent, callID: dispatch.callID,
+                        args: legacyToolInput("subagent", dispatch.input) }, output);
+                    if (dispatch.child)
+                        await syncReviewerCorrectionPermissions(context, hooks, dispatch.child);
+                    // Inline Review already has a compact provenance receipt; retain the full diagnostic packet in its ordinary tool route.
+                    try {
+                        const packet = JSON.parse(output.output);
+                        if (record(packet) && record(packet.completion_receipt))
+                            return JSON.stringify(packet.completion_receipt);
+                    }
+                    catch { /* Ordinary native outputs are not necessarily JSON. */ }
+                    return output.output;
+                }, (callID, restore) => hooks.backgroundOwner?.(callID, restore), (parent, callID, child, promptID) => hooks.backgroundResult?.(parent, callID, child, promptID) ?? Promise.resolve(undefined));
+                hooks = await legacyFactory({ directory: context.location.directory, client: legacyClient(context),
+                    nativeBackground: background, returnReportTransport: "tool-result",
+                    reviewerCorrectionPermissions: !!context.agent && !!context.storage && !!context.session.switchAgent }, context.options ?? {});
+                await registerV2Hooks(context, hooks, background, liveState);
+                // Recreate exact durable correction profiles at plugin setup, before resumed native Steps
+                // resolve their agent/tool snapshots. Storage.scan is part of Plugin 2.0.18's public domain.
+                if (context.storage?.scan) {
+                    let after;
+                    do {
+                        const page = await context.storage.scan({ prefix: correctionStoragePrefix, ...(after ? { after } : {}) });
+                        for (const entry of page.entries)
+                            await syncReviewerCorrectionPermissions(context, hooks, entry.key.slice(correctionStoragePrefix.length));
+                        after = page.next;
+                    } while (after);
                 }
-                if (event.type === "session.compaction.ended")
-                    await hooks.event?.({ event: { type: "session.compacted", properties: { sessionID: id } } });
-            };
-            void (async () => {
-                for await (const event of context.event.subscribe({ signal: controller.signal })) {
+                const finalize = createV2ReturnReportFinalizer(context, hooks);
+                const controller = new AbortController();
+                const eventOperations = new Map();
+                const handleEvent = async (event) => {
                     const data = record(event.data) ? event.data : {};
-                    const lane = string(data.sessionID) ?? "filesystem";
-                    const operation = (eventOperations.get(lane) ?? Promise.resolve()).then(() => handleEvent(event)).catch(error => {
-                        console.warn("[sortie-dogs-v010] V2 event handling failed", error instanceof Error ? error.message : "unknown");
-                    }).finally(() => { if (eventOperations.get(lane) === operation)
-                        eventOperations.delete(lane); });
-                    eventOperations.set(lane, operation);
-                }
-            })().catch(error => {
-                if (!controller.signal.aborted)
-                    console.warn("[sortie-dogs-v010] V2 event adapter stopped", error instanceof Error ? error.message : "unknown");
-            });
-            return () => controller.abort();
+                    const id = string(data.sessionID);
+                    if (event.type === "filesystem.changed" && typeof data.file === "string") {
+                        await hooks.event?.({ event: { type: "file.edited", properties: { file: data.file } } });
+                        return;
+                    }
+                    if (id === undefined)
+                        return;
+                    try {
+                        if (String(event.type).startsWith("session.execution.") || event.type === "session.inbox.enqueued" || event.type === "session.idle")
+                            await background.event(event);
+                        if (event.type === "session.deleted") {
+                            await context.storage?.remove?.(childSelectionKey(id));
+                            liveState.delete(id);
+                            await context.storage?.remove?.(liveStateKey(id));
+                            // This native event is definite deletion, unlike a transient session.get failure.
+                            await disposeCorrectionPermissions(context, id);
+                        }
+                        if (event.type === "session.execution.succeeded")
+                            await finalize(id);
+                        if (event.type === "session.created" || event.type === "session.deleted" || event.type === "session.idle") {
+                            const info = event.type === "session.created" ? await context.session.get({ sessionID: id }).catch(() => ({ id })) : { id };
+                            await hooks.event?.({ event: { type: String(event.type), properties: { sessionID: id, info } } });
+                            for (const child of await hooks.reviewerCorrectionSessions?.(id) ?? [])
+                                await syncReviewerCorrectionPermissions(context, hooks, child);
+                            if (event.type !== "session.deleted")
+                                await syncReviewerCorrectionPermissions(context, hooks, id);
+                        }
+                        if (event.type === "session.compaction.ended")
+                            await hooks.event?.({ event: { type: "session.compacted", properties: { sessionID: id } } });
+                    }
+                    finally {
+                        if (event.type === "session.deleted")
+                            forgetWorkSession(context.location.directory, id);
+                    }
+                };
+                void (async () => {
+                    for await (const event of context.event.subscribe({ signal: controller.signal })) {
+                        const data = record(event.data) ? event.data : {};
+                        const lane = string(data.sessionID) ?? "filesystem";
+                        const operation = (eventOperations.get(lane) ?? Promise.resolve()).then(() => handleEvent(event)).catch(error => {
+                            console.warn("[sortie-dogs-v010] V2 event handling failed", error instanceof Error ? error.message : "unknown");
+                        }).finally(() => { if (eventOperations.get(lane) === operation)
+                            eventOperations.delete(lane); });
+                        eventOperations.set(lane, operation);
+                    }
+                })().catch(error => {
+                    if (!controller.signal.aborted)
+                        console.warn("[sortie-dogs-v010] V2 event adapter stopped", error instanceof Error ? error.message : "unknown");
+                });
+                return () => { controller.abort(); releaseWork(); };
+            }
+            catch (error) {
+                releaseWork();
+                throw error;
+            }
         },
     };
 }

package/package.json

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