sortie-dogs 0.5.2 → 0.5.4

package/README.md

@@ -20,7 +20,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.5.2](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.2)
+Release: [v0.5.4](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.4)
 
 ## Quick start
 

package/dist/asset-version.d.ts

@@ -2,5 +2,5 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export declare const RUNTIME_ASSET_VERSION = "0.3.33-readable-terminal-report-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.34-parallel-host-contract-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -2,4 +2,4 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export const RUNTIME_ASSET_VERSION = "0.3.33-readable-terminal-report-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.34-parallel-host-contract-v1";

package/dist/core/worktree-commit-artifact.d.ts

@@ -4,6 +4,7 @@ export declare class WorktreeCommitArtifactError extends Error {
     readonly code: WorktreeCommitArtifactErrorCode;
     constructor(code: WorktreeCommitArtifactErrorCode, message: string);
 }
+export declare function resolveValidationExecutable(executable: string): Promise<string | undefined>;
 /** Runs one bounded command without exposing output or performing Git mutations. */
 export declare function runContainedValidation(request: ContainedValidationRequest): Promise<ContainedValidationResult>;
 export declare function produceWorktreeCommitArtifact(request: WorktreeCommitProduceRequest): Promise<WorktreeCommitArtifact>;

package/dist/core/worktree-commit-artifact.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
-import { isAbsolute, join, resolve, sep } from "node:path";
+import { delimiter, extname, isAbsolute, join, resolve, sep } from "node:path";
 import { normalizeWorktreeScopePath } from "./worktree-scope.js";
 const SHA = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/u;
 const HASH = /^[0-9a-f]{64}$/u;
@@ -368,6 +368,26 @@ function exactKeys(value, keys) {
 function validText(value, max = 256) {
     return typeof value === "string" && value.length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/u.test(value);
 }
+export async function resolveValidationExecutable(executable) {
+    if (isAbsolute(executable))
+        return realpath(executable).catch(() => undefined);
+    if (!validText(executable, MAX_COMMAND_TEXT) || executable.startsWith("-") || /[\\/]/u.test(executable))
+        return undefined;
+    const path = process.env.PATH ?? process.env.Path;
+    if (path === undefined)
+        return undefined;
+    const extensions = process.platform === "win32" && extname(executable).length === 0
+        ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((value) => value.length > 0)
+        : [""];
+    for (const directory of path.split(delimiter)) {
+        for (const extension of extensions) {
+            const candidate = await realpath(resolve(directory || ".", `${executable}${extension}`)).catch(() => undefined);
+            if (candidate !== undefined && isAbsolute(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
 function pathIdentity(value) {
     const normalized = resolve(value).split(sep).join("/");
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -550,6 +570,10 @@ async function runBounded(executable, args, cwd, timeout, kind) {
         clearTimeout(timer);
     }
 }
+function boundedCommandKind(executable, args) {
+    return /(?:^|[\\/])git(?:\.exe)?$/iu.test(executable) && args.length === 2 &&
+        args[0] === "diff" && args[1] === "--check" ? "git" : "validation";
+}
 /** Runs one bounded command without exposing output or performing Git mutations. */
 export async function runContainedValidation(request) {
     const suppliedArgs = isRecord(request) && Array.isArray(request.args) ? request.args : [];
@@ -560,21 +584,23 @@ export async function runContainedValidation(request) {
     const failed = (command, exitCode, error) => Object.freeze({ ok: false, command, exit_code: exitCode,
         fingerprint: createHash("sha256").update(JSON.stringify([command, exitCode, error])).digest("hex"), error });
     if (!isRecord(request) || !exactKeys(request, ["cwd", "executable", "timeout_ms", ...(request.args === undefined ? [] : ["args"])]) ||
-        !validText(request.executable, MAX_COMMAND_TEXT) || !isAbsolute(request.executable) ||
+        !validText(request.executable, MAX_COMMAND_TEXT) ||
+        (!isAbsolute(request.executable) && (request.executable.startsWith("-") || /[\\/]/u.test(request.executable))) ||
         !validText(request.cwd, MAX_PATH) || !isAbsolute(request.cwd) ||
         !Number.isInteger(request.timeout_ms) || request.timeout_ms < 1 || request.timeout_ms > MAX_TIMEOUT ||
         !Array.isArray(suppliedArgs) || suppliedArgs.length > MAX_ARGUMENTS ||
         !suppliedArgs.every((arg) => validText(arg, MAX_COMMAND_TEXT)))
         return failed(fallbackCommand, null, "invalid-request");
     const [executable, cwd] = await Promise.all([
-        realpath(request.executable).catch(() => undefined), realpath(request.cwd).catch(() => undefined),
+        resolveValidationExecutable(request.executable),
+        realpath(request.cwd).catch(() => undefined),
     ]);
-    if (executable === undefined || cwd === undefined || !isAbsolute(executable) || !isAbsolute(cwd)) {
+    if (executable === undefined || cwd === undefined || !isAbsolute(cwd)) {
         return failed(fallbackCommand, null, "invalid-request");
     }
     const command = Object.freeze([executable, ...suppliedArgs]);
     try {
-        const result = await runBounded(executable, suppliedArgs, cwd, request.timeout_ms, "validation");
+        const result = await runBounded(executable, suppliedArgs, cwd, request.timeout_ms, boundedCommandKind(executable, suppliedArgs));
         const fingerprint = createHash("sha256").update(JSON.stringify([command, result.code])).digest("hex");
         return result.code === 0
             ? Object.freeze({ ok: true, command, exit_code: 0, fingerprint, error: null })
@@ -679,12 +705,15 @@ function parseStatus(source, staged) {
             throw new WorktreeCommitArtifactError("invalid-state", "Git status is ambiguous.");
         const x = field[0];
         const y = field[1];
-        const untracked = staged === "forbid" && x === "?" && y === "?";
+        const untracked = x === "?" && y === "?";
         if (!untracked && (x === "?" || y === "?" || x === "!" || y === "!" || "RCUT".includes(x) || "RCUT".includes(y))) {
             throw new WorktreeCommitArtifactError("invalid-state", "Untracked, renamed, copied, or unsupported changes are forbidden.");
         }
-        if ((!untracked && staged === "forbid" && (x !== " " || y !== "M" && y !== "D")) ||
-            (staged === "require" && ((x !== "A" && x !== "M" && x !== "D") || y !== " "))) {
+        const unstagedEdit = x === " " && (y === "M" || y === "D");
+        const stagedEdit = (x === "A" || x === "M" || x === "D") && y === " ";
+        if ((!untracked && staged === "forbid" && !unstagedEdit) ||
+            (!untracked && staged === "require" && !stagedEdit) ||
+            (!untracked && staged === "either" && !unstagedEdit && !stagedEdit)) {
             throw new WorktreeCommitArtifactError("invalid-state", "Index or worktree status is not an accepted implementation edit.");
         }
         const path = field.slice(3);
@@ -695,7 +724,7 @@ function parseStatus(source, staged) {
         catch {
             throw new WorktreeCommitArtifactError("invalid-state", "Changed path is not canonical.");
         }
-        entries.push({ code: untracked ? "A" : staged === "forbid" ? y : x, path });
+        entries.push({ code: untracked ? "A" : stagedEdit ? x : y, path });
         if (folded.length === 0)
             throw new WorktreeCommitArtifactError("invalid-state", "Changed path is invalid.");
     }
@@ -714,9 +743,34 @@ function assertScope(entries, scope) {
     }
 }
 async function status(context, staged) {
-    return parseStatus(await context.git([
+    const entries = parseStatus(await context.git([
         "status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignore-submodules=none",
     ]), staged);
+    const controls = new Set([
+        `handoff.${context.descriptor.task_id}.json`,
+        `${context.descriptor.task_id}.operation-manifest.json`,
+    ]);
+    return entries.filter(({ code, path }) => code !== "A" || !controls.has(path));
+}
+async function stagedPaths(context) {
+    if ((await context.git(["ls-files", "-u", "-z"])).length !== 0) {
+        throw new WorktreeCommitArtifactError("invalid-state", "An unmerged index is forbidden.");
+    }
+    const fields = decodeGitOutput(await context.git([
+        "diff", "--cached", "--name-only", "--no-renames", "-z", "--",
+    ]), "Staged path encoding is invalid.").split("\0");
+    if (fields.at(-1) !== "")
+        throw new WorktreeCommitArtifactError("invalid-state", "Staged paths are ambiguous.");
+    fields.pop();
+    for (const path of fields) {
+        if (normalizeWorktreeScopePath(path) !== path) {
+            throw new WorktreeCommitArtifactError("invalid-state", "A staged path is not canonical.");
+        }
+    }
+    if (new Set(fields.map((path) => path.toLowerCase())).size !== fields.length) {
+        throw new WorktreeCommitArtifactError("invalid-state", "Staged path identities are ambiguous.");
+    }
+    return new Set(fields);
 }
 async function assertNoSubmodules(context, entries) {
     for (const entry of entries) {
@@ -884,9 +938,7 @@ async function committedEntries(context, base, commit) {
 }
 async function validateCommit(context, artifact) {
     await assertBaseState(context, artifact.commit_sha);
-    if ((await context.git([
-        "status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignore-submodules=none",
-    ])).length !== 0) {
+    if ((await status(context, "forbid")).length !== 0) {
         throw new WorktreeCommitArtifactError("verification-failed", "Committed checkout is not clean.");
     }
     const parentLine = (await context.git(["rev-list", "--parents", "-n", "1", artifact.commit_sha])).toString("utf8").trim().split(" ");
@@ -934,7 +986,9 @@ export async function produceWorktreeCommitArtifact(request) {
     if (!isRecord(request) || !exactKeys(request, ["descriptor", "managed_path", "validation", ...(request.git_path === undefined ? [] : ["git_path"])]) ||
         !isRecord(request.validation) || !exactKeys(request.validation, ["executable", ...(request.validation.args === undefined ? [] : ["args"]),
         ...(request.validation.timeout_ms === undefined ? [] : ["timeout_ms"])]) ||
-        !validText(request.validation.executable, MAX_COMMAND_TEXT) || !isAbsolute(request.validation.executable) ||
+        !validText(request.validation.executable, MAX_COMMAND_TEXT) ||
+        (!isAbsolute(request.validation.executable) &&
+            (request.validation.executable.startsWith("-") || /[\\/]/u.test(request.validation.executable))) ||
         (request.validation.args !== undefined && (!Array.isArray(request.validation.args) || request.validation.args.length > MAX_ARGUMENTS ||
             !request.validation.args.every((arg) => validText(arg, MAX_COMMAND_TEXT)))) ||
         (request.validation.timeout_ms !== undefined && (!Number.isInteger(request.validation.timeout_ms) ||
@@ -942,26 +996,38 @@ export async function produceWorktreeCommitArtifact(request) {
         throw new WorktreeCommitArtifactError("invalid-request", "Commit producer request is invalid.");
     }
     const context = await makeContext(request);
-    const executable = await realpath(request.validation.executable).catch(() => undefined);
+    const executable = await resolveValidationExecutable(request.validation.executable);
     if (executable === undefined || !isAbsolute(executable)) {
         throw new WorktreeCommitArtifactError("invalid-request", "Validation executable does not exist.");
     }
     const command = Object.freeze([executable, ...(request.validation.args ?? [])]);
     await assertBaseState(context, context.descriptor.base_sha);
-    const before = await status(context, "forbid");
+    const before = await status(context, "either");
     if (before.length === 0)
         throw new WorktreeCommitArtifactError("invalid-state", "No implementation changes exist.");
     assertScope(before, context.descriptor.scope_write);
     await assertNoSubmodules(context, before);
+    const staged = await stagedPaths(context);
+    const hostStaged = staged.size > 0;
+    if (hostStaged && (boundedCommandKind(executable, request.validation.args ?? []) !== "git" ||
+        staged.size !== before.length || !before.every(({ path }) => staged.has(path)))) {
+        throw new WorktreeCommitArtifactError("invalid-state", "Staged changes are not an exact host snapshot of the implementation.");
+    }
     const beforeFingerprint = await changeFingerprint(context, before, "worktree");
-    const validation = await runBounded(executable, request.validation.args ?? [], context.managedPath, request.validation.timeout_ms ?? GIT_TIMEOUT, "validation");
+    const validation = await runBounded(executable, request.validation.args ?? [], context.managedPath, request.validation.timeout_ms ?? GIT_TIMEOUT, boundedCommandKind(executable, request.validation.args ?? []));
     if (validation.code !== 0)
         throw new WorktreeCommitArtifactError("validation-failed", validation.code === 240 ? "Validation containment setup failed."
             : validation.code === 241 ? "Validation left a descendant process."
                 : validation.code === 238 ? "Validation exceeded its resource bound."
                     : "Validation exited unsuccessfully.");
+    if (hostStaged) {
+        const stagedValidation = await runBounded(executable, ["diff", "--cached", "--check"], context.managedPath, request.validation.timeout_ms ?? GIT_TIMEOUT, "git");
+        if (stagedValidation.code !== 0) {
+            throw new WorktreeCommitArtifactError("validation-failed", "Staged implementation validation exited unsuccessfully.");
+        }
+    }
     await assertBaseState(context, context.descriptor.base_sha);
-    const after = await status(context, "forbid");
+    const after = await status(context, "either");
     assertScope(after, context.descriptor.scope_write);
     await assertNoSubmodules(context, after);
     if (JSON.stringify(after) !== JSON.stringify(before) || await changeFingerprint(context, after, "worktree") !== beforeFingerprint) {
@@ -1000,7 +1066,9 @@ export async function recoverWorktreeCommitArtifact(request) {
     if (!isRecord(request) || !exactKeys(request, ["descriptor", "managed_path", "validation", ...(request.git_path === undefined ? [] : ["git_path"])]) ||
         !isRecord(request.validation) || !exactKeys(request.validation, ["executable", ...(request.validation.args === undefined ? [] : ["args"]),
         ...(request.validation.timeout_ms === undefined ? [] : ["timeout_ms"])]) ||
-        !validText(request.validation.executable, MAX_COMMAND_TEXT) || !isAbsolute(request.validation.executable) ||
+        !validText(request.validation.executable, MAX_COMMAND_TEXT) ||
+        (!isAbsolute(request.validation.executable) &&
+            (request.validation.executable.startsWith("-") || /[\\/]/u.test(request.validation.executable))) ||
         (request.validation.args !== undefined && (!Array.isArray(request.validation.args) || request.validation.args.length > MAX_ARGUMENTS ||
             !request.validation.args.every((arg) => validText(arg, MAX_COMMAND_TEXT)))) ||
         (request.validation.timeout_ms !== undefined && (!Number.isInteger(request.validation.timeout_ms) ||
@@ -1008,7 +1076,7 @@ export async function recoverWorktreeCommitArtifact(request) {
         throw new WorktreeCommitArtifactError("invalid-request", "Commit recovery request is invalid.");
     }
     const context = await makeContext(request);
-    const executable = await realpath(request.validation.executable).catch(() => undefined);
+    const executable = await resolveValidationExecutable(request.validation.executable);
     if (executable === undefined || !isAbsolute(executable)) {
         throw new WorktreeCommitArtifactError("invalid-request", "Validation executable does not exist.");
     }
@@ -1019,9 +1087,7 @@ export async function recoverWorktreeCommitArtifact(request) {
     }
     if (state.head === context.descriptor.base_sha)
         return undefined;
-    if ((await context.git([
-        "status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignore-submodules=none",
-    ])).length !== 0) {
+    if ((await status(context, "forbid")).length !== 0) {
         throw new WorktreeCommitArtifactError("invalid-state", "Managed checkout is not clean.");
     }
     const parentLine = (await context.git(["rev-list", "--parents", "-n", "1", state.head])).toString("utf8").trim().split(" ");

package/dist/core/worktree-lifecycle.js

@@ -20,7 +20,7 @@ const SHA = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/u;
 const HASH = /^[0-9a-f]{64}$/u;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 const DEVICE_ID = /^[1-9][0-9]*$/u;
-const MAX_SAFE_FILE_ID = BigInt(Number.MAX_SAFE_INTEGER);
+const MAX_FILE_ID = (1n << 64n) - 1n;
 const ACTIVE_PATH = /^wt-([0-9a-f]{16})-([0-9a-f]{32})$/u;
 const QUARANTINE_PATH = /^rm-([0-9a-f]{16})-([0-9a-f]{32})$/u;
 const PHASES = new Set(["creating", "setting-up", "ready", "removing", "orphaned"]);
@@ -53,10 +53,10 @@ function pathWithin(path, parent) {
     return childID === parentID || childID.startsWith(`${parentID}/`);
 }
 function safeStoredFileID(value) {
-    return typeof value === "string" && DEVICE_ID.test(value) && BigInt(value) <= MAX_SAFE_FILE_ID;
+    return typeof value === "string" && DEVICE_ID.test(value) && BigInt(value) <= MAX_FILE_ID;
 }
 function fileID(path, value, kind) {
-    const native = value > 0n && value <= MAX_SAFE_FILE_ID ? value.toString() : undefined;
+    const native = value > 0n && value <= MAX_FILE_ID ? value.toString() : undefined;
     if (native !== undefined)
         return native;
     if (process.platform !== "win32" || (kind === "inode" && value === 0n))

package/dist/plugin/continuation.js

@@ -885,7 +885,7 @@ export function createContinuationHooks(client, directory, policySource, timings
                     identity.agent !== policy().agent)
                     return;
             }
-            if (pending || state?.ownsHostContinuation === true)
+            if (pending || (state?.ownsHostContinuation === true && input.overflow !== true))
                 output.enabled = false;
         },
         observeModel(sessionID, model, synthetic = false) {

package/dist/plugin/fast-lane.d.ts

@@ -6,6 +6,7 @@ export declare class FastLaneDeniedError extends Error {
 }
 export interface FastLaneToolOptions {
     readonly consultationFallbackAuthorized?: boolean;
+    readonly parallelWorkerAlreadyBound?: boolean;
     readonly parallelWorkerAuthorized?: boolean;
 }
 export declare class FastLaneController {

package/dist/plugin/fast-lane.js

@@ -165,7 +165,7 @@ export class FastLaneController {
         state.parallelMode = true;
         state.workerLimit = totalTasks;
         state.workerDispatches = running;
-        state.totalWorkerDispatches = Math.max(state.totalWorkerDispatches, dispatched);
+        state.totalWorkerDispatches = dispatched;
     }
     continuationQueued(sessionID) {
         const state = this.sessions.get(sessionID);
@@ -224,9 +224,19 @@ export class FastLaneController {
                 throw new FastLaneDeniedError("WORKER_RESUME_INVALID");
             }
             if (state.parallelMode) {
-                if (options.parallelWorkerAuthorized !== true || state.workerDispatches >= state.parallelWorkerLimit ||
-                    state.totalWorkerDispatches >= state.workerLimit)
+                if (options.parallelWorkerAuthorized !== true)
                     throw new FastLaneDeniedError("WORKER_LIMIT");
+                if (options.parallelWorkerAlreadyBound === true) {
+                    if (state.workerDispatches < 1 || state.workerDispatches > state.parallelWorkerLimit ||
+                        state.totalWorkerDispatches < 1 || state.totalWorkerDispatches > state.workerLimit) {
+                        throw new FastLaneDeniedError("WORKER_LIMIT");
+                    }
+                    state.workerInFlight = true;
+                    return;
+                }
+                if (state.workerDispatches >= state.parallelWorkerLimit || state.totalWorkerDispatches >= state.workerLimit) {
+                    throw new FastLaneDeniedError("WORKER_LIMIT");
+                }
             }
             else if (state.backlogDrain &&
                 (state.workerDispatches >= 1 || state.totalWorkerDispatches >= state.workerLimit)) {