sortie-dogs 0.16.0 → 0.16.1

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.16.0-purpose-aligned-v2";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.1-review-git-boundary-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";
 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.16.0-purpose-aligned-v2";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.1-review-git-boundary-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

package/dist/plugin/mission-review.js

@@ -683,12 +683,66 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
             local.push(scoped || ".");
     }
     const toolInput = scope.read.some(path => normalizeManifestScope(path).path.startsWith(TOOL_ENVIRONMENT));
-    const gitScopes = [...local, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
+    // A Location may inherit an ancestor repository while its actual outputs live in a
+    // nested repository/worktree. Resolve that boundary before asking the outer Git:
+    // ls-files can return the whole ignored repository (or fail internally) for a narrow output.
+    const rootLocal = [], nested = new Map();
+    for (const path of local) {
+        let current = resolve(directory), repository;
+        for (const part of path.split("/")) {
+            current = resolve(current, part);
+            const info = await lstat(current).catch((error) => {
+                if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
+                    throw error;
+                return undefined;
+            });
+            if (!info?.isDirectory())
+                break; // Missing files and symlink targets are not traversed.
+            if (current === resolve(directory))
+                continue;
+            const metadata = await lstat(join(current, ".git")).catch((error) => {
+                if (error.code !== "ENOENT")
+                    throw error;
+                return undefined;
+            });
+            if (metadata)
+                repository = current; // Includes .git files and broken worktrees: Git must diagnose them.
+        }
+        if (repository)
+            nested.set(repository, [...(nested.get(repository) ?? []), relative(repository, resolve(directory, path)).replaceAll("\\", "/") || "."]);
+        else
+            rootLocal.push(path);
+    }
+    const gitScopes = [...rootLocal, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
     const git = async (args) => (await exec("git", args, { cwd: directory, maxBuffer: 8 * 1024 * 1024 })).stdout;
     let names = "", ignored = "", repository = true, scopedDiff = "";
     const untracked = new Set(), currentFiles = new Set();
+    const collected = new Set();
+    const collectRepository = async (absolute, path, pathspec) => {
+        const scopedGit = async (args) => (await exec("git", args, { cwd: absolute, maxBuffer: 8 * 1024 * 1024 })).stdout;
+        const tracked = await scopedGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspec]);
+        const prefix = (name) => join(path, name).replaceAll("\\", "/");
+        for (const name of tracked.split("\0").filter(Boolean)) {
+            collected.add(prefix(name));
+            currentFiles.add(prefix(name));
+        }
+        for (const name of (await scopedGit(["ls-files", "-z", "--others", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean))
+            untracked.add(prefix(name));
+        for (const name of (await scopedGit(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean)) {
+            collected.add(prefix(name));
+            untracked.add(prefix(name));
+        }
+        // The Mission baseline belongs to its root, not these different repositories.
+        // Without a baseline here, committed outputs still appear as current content.
+        const delta = await currentGitDiff(scopedGit, pathspec);
+        if (delta)
+            scopedDiff += `\n--- repository output: ${path} ---\n${delta}`;
+    };
+    for (const [absolute, paths] of nested) {
+        await collectRepository(absolute, relative(directory, absolute).replaceAll("\\", "/"), paths);
+    }
     try {
-        if (local.length) {
+        if (rootLocal.length) {
             names = await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...gitScopes]);
             for (const path of (await git(["ls-files", "-z", "--others", "--exclude-standard", "--", ...gitScopes])).split("\0").filter(Boolean))
                 untracked.add(path);
@@ -701,7 +755,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         repository = false;
         // Mission storage can be outside Git while its declared outputs are repositories,
         // worktrees or plain files. Inventory those outputs in place, not the storage root.
-        const collected = new Set(), walked = new Set();
+        const walked = new Set();
         const collect = async (path) => {
             if (walked.has(path) || excluded(path))
                 return;
@@ -719,11 +773,9 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
                 untracked.add(path);
                 return;
             }
-            const scopedGit = async (args) => (await exec("git", args, { cwd: absolute, maxBuffer: 8 * 1024 * 1024 })).stdout;
-            const pathspec = ["."]; // Shared tooling is rooted at the Mission, not each output repository.
-            let tracked;
+            // Shared tooling is rooted at the Mission, not each output repository.
             try {
-                tracked = await scopedGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspec]);
+                await collectRepository(absolute, path, ["."]);
             }
             catch (error) {
                 if (!notRepository(error))
@@ -733,27 +785,11 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
                 }
                 return;
             }
-            const prefix = (name) => join(path, name).replaceAll("\\", "/");
-            for (const name of tracked.split("\0").filter(Boolean)) {
-                collected.add(prefix(name));
-                currentFiles.add(prefix(name));
-            }
-            for (const name of (await scopedGit(["ls-files", "-z", "--others", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean))
-                untracked.add(prefix(name));
-            for (const name of (await scopedGit(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...pathspec])).split("\0").filter(Boolean)) {
-                collected.add(prefix(name));
-                untracked.add(prefix(name));
-            }
-            // The mission's baseline belongs to its root, not to these different repositories.
-            // With no baseline here, committed outputs still appear as current file content.
-            const delta = await currentGitDiff(scopedGit, pathspec);
-            if (delta)
-                scopedDiff += `\n--- repository output: ${path} ---\n${delta}`;
         };
-        for (const path of local)
+        for (const path of rootLocal)
             await collect(path);
-        names = [...collected].sort().join("\0");
     }
+    names = [...new Set([...names.split("\0").filter(Boolean), ...collected])].sort().join("\0");
     // Go's ignored in-project caches may be writable during validation but are not candidate
     // output. Keep every other ignored declared output visible and fingerprinted, including
     // directories of generated artifacts; focused references can still pin a cache file.
@@ -763,7 +799,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
     const unreadable = [];
     const outsideLinks = [];
     let diff = scopedDiff;
-    if (repository && local.length && displayBaseline) {
+    if (repository && rootLocal.length && displayBaseline) {
         // HEAD-only diffs are empty once the author commits. Display the original mission delta
         // or the focused correction delta without changing the full fingerprint basis.
         const changed = (await git(["diff", "--name-only", "-z", "--no-ext-diff", displayBaseline, "--", ...gitScopes]))
@@ -774,7 +810,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         const available = Math.max(0, 24_000 - Buffer.byteLength(selected + heading) -
             headers.reduce((size, title) => size + Buffer.byteLength(title), 0) - 500);
         const allowance = shown.length ? Math.min(3_000, Math.floor(available / shown.length)) : 0;
-        diff = heading;
+        diff += heading;
         for (const [index, path] of shown.entries()) {
             const patch = await git(["diff", "--no-ext-diff", "--no-textconv", displayBaseline, "--", path]);
             const bytes = Buffer.from(patch);
@@ -788,8 +824,8 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         }
         omitted.push(...changed.slice(shown.length));
     }
-    else if (repository && local.length) {
-        diff = await currentGitDiff(git, gitScopes);
+    else if (repository && rootLocal.length) {
+        diff += await currentGitDiff(git, gitScopes);
     }
     const unchanged = diff.length === 0;
     let excerpt = selected + diff;

package/dist/plugin/native-background.d.ts

@@ -25,6 +25,7 @@ export declare class NativeBackgroundLifecycle {
     private readonly recoverResult?;
     private readonly operations;
     private readonly restored;
+    private readonly reconciliationErrors;
     constructor(context: OpenCodeV2Context, settle: (dispatch: NativeBackgroundDispatch, text: string) => Promise<string | void>, owner?: ((callID: string, restore?: ObjectValue) => ObjectValue | undefined) | undefined, recoverResult?: ((parent: string, callID: string, child: string, promptID?: string) => Promise<string | undefined>) | undefined);
     private serial;
     private read;
@@ -33,6 +34,7 @@ export declare class NativeBackgroundLifecycle {
     bind(parent: string, child: string, agent: string, prompt: string, promptID?: string): Promise<void>;
     launched(parent: string, callID: string, child: string | undefined, running: boolean): Promise<boolean>;
     awaiting(sessionID: string): Promise<boolean>;
+    reconciliationNotice(parent: string): string | undefined;
     reconcile(parent: string): Promise<void>;
     /** Add provenance beside its existing native notification, without editing history or waking the parent again. */
     project(parent: string, messages: readonly unknown[]): Promise<unknown[]>;

package/dist/plugin/native-background.js

@@ -9,6 +9,7 @@ export class NativeBackgroundLifecycle {
     recoverResult;
     operations = new Map();
     restored = new Set();
+    reconciliationErrors = new Map();
     constructor(context, settle, owner, recoverResult) {
         this.context = context;
         this.settle = settle;
@@ -85,8 +86,22 @@ export class NativeBackgroundLifecycle {
         return object(info) && typeof info.parentID === "string" &&
             (await this.read(info.parentID)).some(item => !item.settled && item.child === sessionID);
     }
+    reconciliationNotice(parent) { return this.reconciliationErrors.get(parent); }
     async reconcile(parent) {
-        await this.serial(parent, async () => this.reconcileInside(parent, await this.read(parent)));
+        try {
+            await this.serial(parent, async () => this.reconcileInside(parent, await this.read(parent)));
+            this.reconciliationErrors.delete(parent);
+        }
+        catch (error) {
+            // This is recovery of existing native work, not admission or acceptance. A failed
+            // inspection must retain its terminal/reservation for idempotent retry without
+            // making the next user prompt, model request or compaction fail before it starts.
+            const reason = error instanceof Error ? error.message : String(error);
+            console.warn("[sortie-dogs-v010] Background reconciliation unavailable; saved work retained", reason);
+            this.reconciliationErrors.set(parent, `SORTIE_BACKGROUND_RECONCILIATION_UNAVAILABLE\n${JSON.stringify(reason.slice(0, 2_000))}\n` +
+                "Native work/results and cumulative spend are retained; formal validation and acceptance are not proven by this recovery failure. " +
+                "Diagnose the failed inspection and reconcile this same invocation after repair. Do not relaunch or repeat an already completed external operation just to repair accounting.");
+        }
     }
     /** Add provenance beside its existing native notification, without editing history or waking the parent again. */
     async project(parent, messages) {

package/dist/plugin/v2.js

@@ -847,6 +847,9 @@ async function registerV2Hooks(context, hooks, background, liveState) {
                 event.messages = await background.project(String(event.sessionID ?? ""), event.messages);
             const output = { system: [] };
             await hooks["experimental.chat.system.transform"]({ sessionID: String(event.sessionID ?? "") }, output);
+            const reconciliation = background.reconciliationNotice(String(event.sessionID ?? ""));
+            if (reconciliation)
+                (output.system ??= []).push(reconciliation);
             await reconcileCorrectionPermissions(String(event.sessionID));
             if (record(event.tools)) {
                 const correcting = correctionAgent(event.agent) && !!await hooks.reviewerCorrectionScope?.(String(event.sessionID));
@@ -913,6 +916,9 @@ async function registerV2Hooks(context, hooks, background, liveState) {
                 }
             const output = { context: [] };
             await hooks["experimental.session.compacting"]({ sessionID: String(event.sessionID ?? "") }, output);
+            const reconciliation = background.reconciliationNotice(String(event.sessionID ?? ""));
+            if (reconciliation)
+                (output.context ??= []).push(reconciliation);
             if (Array.isArray(event.system))
                 event.system.push(...output.context.map(text => ({ type: "text", text })));
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",