sortie-dogs 0.13.19 → 0.13.21

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.21](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.21)**
+· [Release notes](docs/release-v0.13.21.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.21
 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.21
 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.21**. 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.21-operation-recovery-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.21](docs/release-v0.13.21.md) · [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.21-operation-recovery-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.21-operation-recovery-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

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

@@ -101,16 +101,30 @@ export interface MissionTerminalRescue {
 export interface MissionExecution {
     commands: string[];
     directory: string;
+    /** History-service availability is not a process outcome or an execution permission. */
+    recovery?: {
+        status: "unavailable";
+        errors: {
+            sessionID: string;
+            reason: string;
+        }[];
+    };
     observations: {
         command: string;
         directory: string;
         callID: string;
         sessionID: string;
         startedAt: string;
+        /** Actual native execution start, distinct from a live hook's admission clock. */
+        nativeStartedAt?: string;
         completedAt?: string;
         exit?: number;
         status?: "running" | "completed" | "error";
         shellID?: string;
+        /** Contradictory native records retained for this same call, not a process outcome. */
+        conflicting?: boolean;
+        /** Latest actual start reported for a conflicting call; original startedAt is retained. */
+        latestConflictingStartedAt?: string;
         outcome?: "not-started" | "execution-failed" | "executed";
         result?: Record<string, unknown>;
     }[];
@@ -314,10 +328,19 @@ export declare function missionReviewVerdict(text: string): "PASS" | "evidence-g
 export declare function missionReviewAccepted(review: NonNullable<OperatorMission["review"]>): boolean;
 /** A short native report, not a tag/hash-based second-review policy or an approval checklist. */
 export declare function missionSelfRecheckReport(text: string, source: string, hostBound?: boolean): Pick<MissionSelfRecheck, "unresolvedFindings" | "residualMajor"> | undefined;
-export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "running" | "execution-failed" | "executed";
+export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "recovery-unavailable" | "recovery-blocked" | "running" | "execution-failed" | "executed";
+/** Native Windows cwd case/separator spelling is not a different operation directory. */
+export declare function missionOperationDirectoryMatch(actual: string, declared: string): boolean;
+/** Match only the same declared operation, allowing its native PowerShell envelope and
+ * an absolute Node/script/path spelling resolved from the unchanged operation cwd. */
+export declare function missionOperationCommandMatch(command: string, declared: readonly string[], directory: string): string | undefined;
+/** Apply the existing no-decoration operation check to the same accepted native spelling. */
+export declare function missionOperationCommandDecorated(command: string, declared: readonly string[], directory: string): boolean;
 /** A terminal failure is a collected result, not a successful operation. Required success
  * remains in the declared formal checks and Operator's original-request comparison. */
 export declare function missionExecutionComplete(mission: OperatorMission): boolean;
+/** Missing history cannot justify replay; adequate collected results remain usable. */
+export declare function missionExecutionRecoveryAction(mission: OperatorMission): string | undefined;
 /** Projection of existing observations only; never another check or inferred success. */
 export declare function missionOperationSummary(mission: OperatorMission): Record<string, unknown>;
 /** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,

package/dist/core/operator-mission.js

@@ -1,10 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join, resolve, win32 } from "node:path";
 import { normalizeExecutionScope } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
-import { normalizeCommand } from "../plugin/gate.js";
+import { normalizeCommand, shellCommandBase, shellCommandWords } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
 import { retainMissionContext, missionContextView } from "./mission-context.js";
 import { planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
@@ -111,22 +111,129 @@ export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
         return "not-required";
     const execution = mission.execution;
-    if (!execution || execution.commands.length === 0 || execution.observations.length === 0)
+    if (!execution || execution.commands.length === 0)
         return "not-started";
-    const latest = execution.commands.map(command => [...execution.observations].reverse().find(item => item.command === command && item.directory === execution.directory));
+    if (execution.observations.length === 0)
+        return execution.recovery ? "recovery-unavailable" : "not-started";
+    // Recovery may discover an older call after a newer live/failed observation was saved.
+    const orderingTime = (item) => Math.max(Date.parse(item.nativeStartedAt ?? item.startedAt), Date.parse(item.latestConflictingStartedAt ?? item.nativeStartedAt ?? item.startedAt));
+    const ordered = [...execution.observations].sort((left, right) => orderingTime(left) - orderingTime(right)).reverse();
+    const latest = execution.commands.map(command => ordered.find(item => item.command === command && item.directory === execution.directory));
+    if (latest.some(item => item?.conflicting || item && ["completed", "error"].includes(item.status ?? "") &&
+        !["executed", "execution-failed", "not-started"].includes(item.outcome ?? "")))
+        return "recovery-blocked";
     if (latest.some(item => item && !item.completedAt))
         return "running";
+    if (latest.some(item => !item) && execution.recovery)
+        return "recovery-unavailable";
     if (latest.some(item => !item || !["executed", "execution-failed"].includes(item.outcome ?? "")))
         return "not-started";
     if (latest.some(item => item?.outcome === "execution-failed" || (item && (item.status === "error" || item.exit !== 0))))
         return "execution-failed";
     return "executed";
 }
+function stripMissionPowerShellPrefix(command) {
+    return command.trim().replace(/^\$ErrorActionPreference\s*=\s*(['"])Stop\1\s*;\s*/iu, "");
+}
+function missionCommandTokens(command) {
+    const tokens = shellCommandWords(stripMissionPowerShellPrefix(command));
+    if (tokens[0] === "&")
+        tokens.shift();
+    return tokens.length ? tokens : undefined;
+}
+function missionWindowsPath(value) {
+    return /^[A-Za-z]:[\\/]/u.test(value) || value.startsWith("\\\\");
+}
+function missionPathIdentity(value, directory, windows) {
+    if (!windows)
+        return resolve(directory, value);
+    return win32.normalize(win32.resolve(directory, value)).toLowerCase();
+}
+/** Native Windows cwd case/separator spelling is not a different operation directory. */
+export function missionOperationDirectoryMatch(actual, declared) {
+    const windows = missionWindowsPath(actual) || missionWindowsPath(declared);
+    return missionPathIdentity(actual, declared, windows) === missionPathIdentity(declared, declared, windows);
+}
+function sameNodeOperation(declared, actual, directory) {
+    const expected = missionCommandTokens(declared), observed = missionCommandTokens(actual);
+    if (!expected || !observed || expected.length !== observed.length || expected.length < 2)
+        return false;
+    const windows = missionWindowsPath(directory);
+    const name = (value) => {
+        const basename = value.split(windows ? /[\\/]/u : /\//u).at(-1) ?? "";
+        return windows ? basename.toLowerCase() : basename;
+    };
+    const nodeNames = windows ? ["node", "node.exe"] : ["node"];
+    if (!nodeNames.includes(name(expected[0])) || !nodeNames.includes(name(observed[0])))
+        return false;
+    const executablePath = (value) => windows ? /[\\/]/u.test(value) : value.includes("/");
+    if (executablePath(expected[0]) && (!executablePath(observed[0]) ||
+        missionPathIdentity(expected[0], directory, windows) !== missionPathIdentity(observed[0], directory, windows)))
+        return false;
+    const script = expected[1];
+    if (!/\.(?:cjs|mjs|js)$/iu.test(script) || !/\.(?:cjs|mjs|js)$/iu.test(observed[1]))
+        return false;
+    if (missionPathIdentity(script, directory, windows) !== missionPathIdentity(observed[1], directory, windows))
+        return false;
+    for (let index = 2; index < expected.length; index += 1) {
+        const left = expected[index], right = observed[index];
+        if (left === right)
+            continue;
+        // Options and URI values are script inputs, not filesystem paths with Windows case rules.
+        const literal = (value) => value.startsWith("-") || !missionWindowsPath(value) && /^[A-Za-z][A-Za-z\d+.-]*:/u.test(value);
+        if (literal(left) || literal(right))
+            return false;
+        // Only the supported absolute-path substitution can change a positional argument.
+        // Two different relative opaque values must not collapse via path normalization.
+        const absolute = (value) => missionWindowsPath(value) || value.startsWith("/");
+        const pathArgument = absolute(left) !== absolute(right) || windows && missionWindowsPath(left) && missionWindowsPath(right);
+        if (pathArgument
+            ? missionPathIdentity(left, directory, windows) !== missionPathIdentity(right, directory, windows)
+            : left !== right)
+            return false;
+    }
+    return true;
+}
+/** Match only the same declared operation, allowing its native PowerShell envelope and
+ * an absolute Node/script/path spelling resolved from the unchanged operation cwd. */
+export function missionOperationCommandMatch(command, declared, directory) {
+    const normalized = normalizeCommand(stripMissionPowerShellPrefix(command));
+    const exact = declared.filter(item => normalizeCommand(stripMissionPowerShellPrefix(item)) === normalized);
+    if (exact.length === 1)
+        return normalizeCommand(exact[0]);
+    if (exact.length > 1)
+        return undefined;
+    const equivalent = declared.filter(item => sameNodeOperation(item, command, directory));
+    return equivalent.length === 1 ? normalizeCommand(equivalent[0]) : undefined;
+}
+/** Apply the existing no-decoration operation check to the same accepted native spelling. */
+export function missionOperationCommandDecorated(command, declared, directory) {
+    if (missionOperationCommandMatch(command, declared, directory) !== undefined)
+        return false;
+    const stripped = stripMissionPowerShellPrefix(command), actual = normalizeCommand(stripped);
+    if (declared.some(item => {
+        const expected = normalizeCommand(stripMissionPowerShellPrefix(item));
+        return actual.startsWith(expected) && /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(expected.length));
+    }))
+        return true;
+    const base = shellCommandBase(stripped, stripped !== command.trim() || stripped.startsWith("&") ? "powershell" : "posix");
+    return base !== undefined && missionOperationCommandMatch(base, declared, directory) !== undefined;
+}
 /** A terminal failure is a collected result, not a successful operation. Required success
  * remains in the declared formal checks and Operator's original-request comparison. */
 export function missionExecutionComplete(mission) {
     return ["not-required", "executed", "execution-failed"].includes(missionExecutionStatus(mission));
 }
+/** Missing history cannot justify replay; adequate collected results remain usable. */
+export function missionExecutionRecoveryAction(mission) {
+    if (missionExecutionStatus(mission) === "recovery-blocked")
+        return "An admitted operation has missing or contradictory terminal evidence. Preserve existing observations; inspect the same native call's shell/progress and recover its actual result. " +
+            "Do not replay or rerun the operation. Report the actual recovery blocker if its result remains unknown.";
+    if (!mission.execution?.recovery || missionExecutionComplete(mission))
+        return undefined;
+    return "Native operation history could not be read. Preserve existing observations; inspect the admitted session's existing shell/progress or restore the history reader. " +
+        "Do not replay or rerun the operation. Report the actual recovery blocker if history remains unavailable.";
+}
 /** Projection of existing observations only; never another check or inferred success. */
 export function missionOperationSummary(mission) {
     const status = missionExecutionStatus(mission);
@@ -836,21 +943,22 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
                             : "Correction ready; reuse the native author for explicit self-recheck or select an independent Reviewer with review_mission when useful. Remaining authorized implementation may proceed with plan_units without acceptance. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
                     : mission.kind === "operation" && operationStatus === "running"
                         ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
-                        : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
-                            ? "Correction validation or native execution failed. Reuse its context with repair_review, select another available Reviewer, or plan_units for Worker/direct correction. Retain findings, affected checks, requested delivery and cumulative spend. Failure is never acceptance."
-                            : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
-                                ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
-                                : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
-                                    ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
-                                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
-                                        ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
-                                        : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                                : run?.phase === "awaiting-acceptance" && !operationComplete
-                                    ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
-                                    : run?.phase === "awaiting-acceptance" ? (reviewAccepted
-                                        ? "Coordinator: review permits submission, not completion of remaining implementation. Continue authorized remaining work with plan_units, or submit when the original requirements are met. Retain review notes; do not repeat passed validation or review for evidence formatting. Operator final acceptance remains separate."
-                                        : "Coordinator: correct known Major/Medium findings, then obtain native author self-recheck or useful independent review (required for concrete residual Major risk). Remaining authorized implementation can proceed without submission/acceptance. Operator compares all requirements with source/evidence before complete_mission.")
-                                        : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
+                        : missionExecutionRecoveryAction(mission) !== undefined ? missionExecutionRecoveryAction(mission)
+                            : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
+                                ? "Correction validation or native execution failed. Reuse its context with repair_review, select another available Reviewer, or plan_units for Worker/direct correction. Retain findings, affected checks, requested delivery and cumulative spend. Failure is never acceptance."
+                                : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
+                                    ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
+                                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
+                                        ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
+                                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
+                                            ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
+                                            : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
+                                    : run?.phase === "awaiting-acceptance" && !operationComplete
+                                        ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
+                                        : run?.phase === "awaiting-acceptance" ? (reviewAccepted
+                                            ? "Coordinator: review permits submission, not completion of remaining implementation. Continue authorized remaining work with plan_units, or submit when the original requirements are met. Retain review notes; do not repeat passed validation or review for evidence formatting. Operator final acceptance remains separate."
+                                            : "Coordinator: correct known Major/Medium findings, then obtain native author self-recheck or useful independent review (required for concrete residual Major risk). Remaining authorized implementation can proceed without submission/acceptance. Operator compares all requirements with source/evidence before complete_mission.")
+                                            : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export function missionReviewTask(mission) {

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/gate.d.ts

@@ -51,7 +51,14 @@ export declare function resolveProjectRoot(input: {
     directory: string;
     worktree?: string;
 }): string;
+/** Reuse the write-gate's quoted shell tokenization for non-authorizing command identity checks. */
+export declare function shellCommandWords(command: string): string[];
+type ShellDialect = "posix" | "powershell";
+/** The command before an unquoted shell suffix, reusing the gate's existing syntax scanner. */
+export declare function shellCommandBase(command: string, dialect: ShellDialect): string | undefined;
 export declare function describeUnclassifiedCommand(tool: string, args: unknown): string | undefined;
+/** Shell tool names already supported by the write gate, including native suffixes. */
+export declare function isShellTool(tool: string): boolean;
 /** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
 export declare function extractWritePaths(tool: string, args: unknown, toolDirectory?: string): Extraction;
 /**

package/dist/plugin/gate.js

@@ -101,6 +101,10 @@ function unquote(value) {
 function words(command) {
     return command.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/gu)?.map(unquote) ?? [];
 }
+/** Reuse the write-gate's quoted shell tokenization for non-authorizing command identity checks. */
+export function shellCommandWords(command) {
+    return words(command);
+}
 function operands(tokens) {
     const result = [];
     for (let index = 1; index < tokens.length; index += 1) {
@@ -411,6 +415,18 @@ function shellSegments(command, dialect) {
     segments.push(command.slice(start));
     return segments;
 }
+/** The command before an unquoted shell suffix, reusing the gate's existing syntax scanner. */
+export function shellCommandBase(command, dialect) {
+    const masked = scanShellSyntax(command, dialect).masked;
+    for (let index = 0; index < masked.length; index += 1) {
+        const character = masked[index];
+        if (!";|><\r\n".includes(character) && !(character === "&" && masked.slice(0, index).trim()))
+            continue;
+        const base = command.slice(0, index);
+        return (character === ">" || character === "<" ? base.replace(/(?:^|\s)\d+$/u, "") : base).trim();
+    }
+    return undefined;
+}
 function depthOnePowerShellLiteral(source) {
     const match = /^\s*(?:"[^"]*(?:pwsh|powershell)(?:\.exe)?"|[^\s"']*(?:pwsh|powershell)(?:\.exe)?)\s+-noprofile\s+-command\s+'((?:''|[^'])*)'\s*$/iu.exec(source);
     return match?.[1].replaceAll("''", "'");
@@ -761,6 +777,10 @@ export function describeUnclassifiedCommand(tool, args) {
     const extracted = extractWritePaths(tool, args);
     return extracted.ambiguous && extracted.issue !== undefined ? issuePath(extracted.issue) : undefined;
 }
+/** Shell tool names already supported by the write gate, including native suffixes. */
+export function isShellTool(tool) {
+    return /^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(tool.toLowerCase());
+}
 /** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
 export function extractWritePaths(tool, args, toolDirectory) {
     const name = tool.toLowerCase();
@@ -774,7 +794,7 @@ export function extractWritePaths(tool, args, toolDirectory) {
         const extracted = patch === undefined ? [] : patchPaths(patch);
         return { applies: true, ambiguous: extracted.length === 0, paths: [...paths, ...extracted] };
     }
-    if (/^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(name)) {
+    if (isShellTool(tool)) {
         const command = isRecord(args) && typeof args.command === "string" ? args.command : undefined;
         if (command === undefined) {
             const ambiguous = paths.length === 0;
@@ -1036,7 +1056,7 @@ export function isKnownReadOnlyTool(tool, args, additionalReadOnlyTools = new Se
     const name = tool.toLowerCase();
     if (READ_ONLY_TOOLS.has(name) || additionalReadOnlyTools.has(name))
         return true;
-    if (!/^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(name))
+    if (!isShellTool(tool))
         return false;
     const extraction = extractWritePaths(tool, args);
     return !extraction.applies && !extraction.ambiguous && extraction.remoteMutation !== true;