sortie-dogs 0.5.2 → 0.5.3

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.3](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.3)
 
 ## 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/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)) {

package/dist/plugin/index.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { readFile, realpath, stat } from "node:fs/promises";
+import { lstat, open, readFile, realpath, rm, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { normalizeRelativePath, RelativePathError } from "../core/path.js";
 import { ScopeLeaseError, ScopeLeaseRegistry } from "../core/scope-lease-registry.js";
-import { produceWorktreeCommitArtifact, recoverWorktreeCommitArtifact, WorktreeCommitArtifactError, } from "../core/worktree-commit-artifact.js";
+import { produceWorktreeCommitArtifact, recoverWorktreeCommitArtifact, resolveValidationExecutable, WorktreeCommitArtifactError, } from "../core/worktree-commit-artifact.js";
 import { normalizeWorktreeScope } from "../core/worktree-scope.js";
 import { ParallelDispatchCoordinator, ParallelDispatchError, } from "../core/worktree-parallel-dispatch.js";
 import { IntegrationQueueError, WorktreeIntegrationQueue } from "../core/worktree-integration-queue.js";
@@ -640,12 +640,12 @@ function parseStringArray(value) {
 function parallelDescriptor(text) {
     const unique = (key) => {
         const values = taskValues(text, [key]);
-        return values.length === 1 ? values[0] : undefined;
+        return values.length > 0 && new Set(values).size === 1 ? values[0] : undefined;
     };
     const runID = unique("run_id");
     const dispatchID = unique("dispatch_id");
     const taskID = unique("task_id");
-    const managedPath = unique("managed_path");
+    const managedPath = unique("managed_path") ?? unique("project_root");
     const branch = unique("branch");
     const baseSHA = unique("base_sha");
     const dependsOn = parseStringArray(unique("depends_on"));
@@ -673,9 +673,11 @@ function sameParallelDescriptor(left, right) {
 function parallelValidationRequest(args) {
     const keys = Object.keys(args).sort();
     const allowed = new Set(["dispatch_id", "run_id", "timeout_ms", "validation_args_json", "validation_executable"]);
+    const executable = args.validation_executable;
     if (!keys.every((key) => allowed.has(key)) ||
         !["dispatch_id", "run_id", "validation_executable"].every((key) => typeof args[key] === "string") ||
-        !isAbsolute(args.validation_executable) || /[\u0000-\u001f\u007f]/u.test(args.validation_executable))
+        /[\u0000-\u001f\u007f]/u.test(executable) ||
+        (!isAbsolute(executable) && (executable.startsWith("-") || /[\\/]/u.test(executable))))
         return undefined;
     let validationArgs = [];
     if (args.validation_args_json !== undefined) {
@@ -700,7 +702,7 @@ function parallelValidationRequest(args) {
             return undefined;
     }
     const validation = {
-        executable: args.validation_executable,
+        executable: executable,
         args: validationArgs,
         ...(timeout === undefined ? {} : { timeout_ms: timeout }),
     };
@@ -1180,6 +1182,103 @@ export const SortieDogsPlugin = async (input, options) => {
             validation: artifact.validation,
         };
     }
+    function parallelControlPaths(descriptor) {
+        return {
+            handoff_path: join(descriptor.managed_path, `handoff.${descriptor.task_id}.json`),
+            operation_manifest: join(descriptor.managed_path, `${descriptor.task_id}.operation-manifest.json`),
+        };
+    }
+    async function createParallelControlFiles(descriptor, validationCommands) {
+        const canonicalRoot = await realpath(descriptor.managed_path);
+        if (!samePath(canonicalRoot, descriptor.managed_path)) {
+            throw new ParallelDispatchError("lifecycle-failed", "Managed worktree identity changed before contract creation.");
+        }
+        const paths = parallelControlPaths(descriptor);
+        const manifestValue = {
+            version: "0.1.0",
+            task_id: descriptor.task_id,
+            read: [...descriptor.scope_read],
+            write: [...descriptor.scope_write],
+            validation: [...validationCommands],
+        };
+        const handoffValue = {
+            version: "0.1.0",
+            profile: "minimal",
+            id: descriptor.task_id,
+            created_at: new Date().toISOString(),
+            ext: { "sortie-dogs/write-gate": {
+                    operation_manifest: basename(paths.operation_manifest),
+                    project_root: descriptor.managed_path,
+                } },
+            task: {
+                title: `Parallel task ${descriptor.task_id}`,
+                objective: "Complete the prepared parallel descriptor within its declared scope.",
+            },
+            state: { done: [], next: ["Implement the prepared parallel descriptor."], blocked: [] },
+            risks: [],
+            verification: validationCommands.map((check) => ({
+                check, status: "not_run", exit_code: null, summary: "Delegated to the parallel artifact capability.",
+            })),
+        };
+        const manifest = validateOperationManifestSchema(manifestValue);
+        const handoff = validateHandoffSchema(handoffValue);
+        if (!manifest.ok || !handoff.ok ||
+            validateManifest(handoff.value, manifest.value, undefined, false, { requirePassedValidation: false })
+                .some(({ severity }) => severity === "error")) {
+            throw new ParallelDispatchError("invalid-contract", "Generated parallel worker contract is invalid.");
+        }
+        const created = [];
+        try {
+            for (const [path, value] of [[paths.operation_manifest, manifestValue], [paths.handoff_path, handoffValue]]) {
+                const content = JSON.stringify(value);
+                try {
+                    const handle = await open(path, "wx", 0o600);
+                    try {
+                        await handle.writeFile(content, "utf8");
+                        await handle.sync();
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                    created.push(path);
+                }
+                catch (error) {
+                    if (!isRecord(error) || error.code !== "EEXIST")
+                        throw error;
+                    const info = await lstat(path);
+                    if (!info.isFile() || info.isSymbolicLink())
+                        throw error;
+                    const existing = await readFile(path, "utf8");
+                    if (existing === content)
+                        continue;
+                    if (path !== paths.handoff_path)
+                        throw error;
+                    const existingValue = JSON.parse(existing);
+                    if (!isRecord(existingValue) || !validateHandoffSchema(existingValue).ok ||
+                        JSON.stringify({ ...existingValue, created_at: handoffValue.created_at }) !== content)
+                        throw error;
+                }
+            }
+        }
+        catch (error) {
+            await Promise.all(created.map((path) => rm(path, { force: true }).catch(() => undefined)));
+            throw error;
+        }
+    }
+    async function removeParallelControlFiles(descriptor) {
+        const paths = parallelControlPaths(descriptor);
+        await Promise.all([
+            rm(paths.handoff_path, { force: true }),
+            rm(paths.operation_manifest, { force: true }),
+        ]);
+    }
+    async function ensureParallelReadyControls(snapshot) {
+        if (snapshot.archived || snapshot.cancelled || snapshot.ready.length === 0)
+            return;
+        await ensureLoaded();
+        const validationCommands = loaded?.manifest?.validation ?? [];
+        await Promise.all(snapshot.ready.map((descriptor) => createParallelControlFiles(descriptor, validationCommands)));
+    }
     function boundedParallelSnapshot(snapshot) {
         return {
             run_id: snapshot.run_id,
@@ -1187,7 +1286,7 @@ export const SortieDogsPlugin = async (input, options) => {
             cancelled: snapshot.cancelled,
             archived: snapshot.archived,
             terminal_reason: snapshot.terminal_reason,
-            ready: snapshot.ready,
+            ready: snapshot.ready.map((descriptor) => ({ ...descriptor, ...parallelControlPaths(descriptor) })),
             tasks: snapshot.tasks.map(({ descriptor, worktree_id, phase, call_id, child_session_id, outcome, artifact }) => ({
                 task_id: descriptor.task_id,
                 worktree_id,
@@ -1257,7 +1356,7 @@ export const SortieDogsPlugin = async (input, options) => {
             if (running === undefined)
                 return deny("dispatch-inactive");
             if (running.artifact !== null) {
-                const executable = await realpath(request.validation.executable).catch(() => undefined);
+                const executable = await resolveValidationExecutable(request.validation.executable);
                 if (executable === undefined)
                     return deny("invalid-request");
                 const requestedCommand = [executable, ...request.validation.args];
@@ -1265,6 +1364,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     return deny("artifact-replay");
                 }
                 await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, running.artifact);
+                await removeParallelControlFiles(binding.descriptor);
                 parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact: running.artifact });
                 pruneParallelChildMap(parallelArtifacts);
                 return JSON.stringify({ status: "created", replay: true, artifact: boundedParallelArtifact(running.artifact) });
@@ -1278,6 +1378,7 @@ export const SortieDogsPlugin = async (input, options) => {
             const recovered = await recoverWorktreeCommitArtifact(produceRequest);
             const artifact = recovered ?? await produceWorktreeCommitArtifact(produceRequest);
             await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, artifact);
+            await removeParallelControlFiles(binding.descriptor);
             parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact });
             pruneParallelChildMap(parallelArtifacts);
             return JSON.stringify({ status: "created", ...(recovered === undefined ? {} : { replay: true }),
@@ -1298,9 +1399,18 @@ export const SortieDogsPlugin = async (input, options) => {
                 !await project.contains(contractPath))
                 return JSON.stringify({ status: "denied", reason: "project-boundary" });
             const contract = await readJson(resolve(contractPath), INPUT_LIMITS.parallel);
-            const result = await (await getParallelCoordinator()).prepare(contract, ownerRoot);
+            const coordinator = await getParallelCoordinator();
+            const result = await coordinator.prepare(contract, ownerRoot);
             if (result.status === "serial-fallback")
                 return JSON.stringify(result);
+            try {
+                await ensureParallelReadyControls(result.snapshot);
+            }
+            catch (error) {
+                await Promise.all(result.snapshot.ready.map((descriptor) => removeParallelControlFiles(descriptor).catch(() => undefined)));
+                await coordinator.cancel(ownerRoot, result.snapshot.run_id).catch(() => undefined);
+                throw error;
+            }
             const dispatched = result.snapshot.tasks.filter(({ phase }) => phase === "running" || phase === "completed" || phase === "failed" || phase === "abandoned").length;
             const running = result.snapshot.tasks.filter(({ phase }) => phase === "running").length;
             fastLane.enableParallelDispatch(ownerRoot, result.snapshot.max_workers, dispatched, running, result.snapshot.tasks.length);
@@ -1322,6 +1432,8 @@ export const SortieDogsPlugin = async (input, options) => {
             const snapshot = reconcile === "true"
                 ? await coordinator.reconcile(ownerRoot, coordinatorTaskCalls.get(ownerRoot) ?? new Set(), runID || undefined)
                 : await coordinator.snapshot(ownerRoot, runID || undefined);
+            if (snapshot !== undefined)
+                await ensureParallelReadyControls(snapshot);
             if (snapshot === undefined && !runID) {
                 const archived = await coordinator.archives(ownerRoot);
                 return JSON.stringify({ status: "ok", active: null, archived: archived.map(boundedParallelArchive) });
@@ -1351,7 +1463,13 @@ export const SortieDogsPlugin = async (input, options) => {
             const ownerRoot = await parallelToolOwner(sessionID);
             if (ownerRoot === undefined)
                 return JSON.stringify({ status: "denied", reason: "coordinator-root-required" });
-            const snapshot = await (await getParallelCoordinator()).cancel(ownerRoot, runID || undefined);
+            const coordinator = await getParallelCoordinator();
+            const active = await coordinator.snapshot(ownerRoot, runID || undefined);
+            const snapshot = await coordinator.cancel(ownerRoot, runID || undefined);
+            if (active !== undefined && snapshot !== undefined) {
+                await Promise.all(active.tasks.filter(({ phase }) => phase === "pending" || phase === "reserved")
+                    .map(({ descriptor }) => removeParallelControlFiles(descriptor).catch(() => undefined)));
+            }
             return snapshot === undefined
                 ? JSON.stringify({ status: "absent" })
                 : JSON.stringify({ status: "cancelled", ...boundedParallelSnapshot(snapshot) });
@@ -2994,6 +3112,10 @@ export const SortieDogsPlugin = async (input, options) => {
                         parallelChildBindings.delete(completedChildSessionID);
                     }
                     if (snapshot !== undefined) {
+                        await ensureParallelReadyControls(snapshot);
+                        if (snapshot.cancelled) {
+                            await removeParallelControlFiles(parallel.descriptor).catch(() => undefined);
+                        }
                         const dispatched = snapshot.tasks.filter(({ phase }) => phase === "running" || phase === "completed" || phase === "failed" || phase === "abandoned").length;
                         const running = snapshot.tasks.filter(({ phase }) => phase === "running").length;
                         fastLane.enableParallelDispatch(parallel.ownerRoot, snapshot.max_workers, dispatched, running, snapshot.tasks.length);
@@ -3056,13 +3178,14 @@ export const SortieDogsPlugin = async (input, options) => {
                 const consultationFallbackAuthorized = role !== undefined &&
                     consultationRetries.get(consultationRetryKey(toolInput.sessionID, role))?.phase === "pending";
                 let parallelWorkerAuthorized = false;
+                let parallelWorkerAlreadyBound = false;
                 let reservedParallelDescriptor;
                 if (toolInput.tool === "task" && taskRole === "dog-worker" && isRecord(output.args)) {
                     const prompt = typeof output.args.prompt === "string" ? output.args.prompt : "";
                     const contractPrompt = taskContractText(prompt);
                     reservedParallelDescriptor = parallelDescriptor(prompt);
                     if (reservedParallelDescriptor !== undefined) {
-                        const roots = taskValues(contractPrompt, ["project_root", "projectroot"]);
+                        const roots = [...new Set(taskValues(contractPrompt, ["project_root", "projectroot"]))];
                         if (roots.length !== 1 || !samePath(roots[0], reservedParallelDescriptor.managed_path)) {
                             throw new HandoffDeniedError("contract-invalid", "<worker-dispatch>", {
                                 defects: [contractDefect("contract", "/managed_path", "parallel_descriptor_project_mismatch")],
@@ -3073,7 +3196,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     const resume = modes.length === 1 && modes[0] === "same-task-resume";
                     const handoffPaths = taskValues(contractPrompt, ["handoff_path", "handoffpath"]);
                     const operationManifests = taskValues(contractPrompt, ["operation_manifest", "operationmanifest"]);
-                    const projectRoots = taskValues(contractPrompt, ["project_root", "projectroot"]);
+                    const projectRoots = [...new Set(taskValues(contractPrompt, ["project_root", "projectroot"]))];
                     const sourceManifests = taskValues(contractPrompt, ["source_manifest", "sourcemanifest"]);
                     const acceptanceValues = taskValues(contractPrompt, ["acceptance"]);
                     const validationValues = taskValues(contractPrompt, ["validation"]);
@@ -3193,14 +3316,21 @@ export const SortieDogsPlugin = async (input, options) => {
                     const snapshot = await coordinator.snapshot(toolInput.sessionID, reservedParallelDescriptor.run_id);
                     if (snapshot === undefined)
                         throw new ParallelDispatchError("descriptor-mismatch", "Parallel run is absent.");
-                    const dispatched = snapshot.tasks.filter(({ phase }) => phase === "running" || phase === "completed" || phase === "failed" || phase === "abandoned").length;
-                    const running = snapshot.tasks.filter(({ phase }) => phase === "running").length;
-                    fastLane.enableParallelDispatch(toolInput.sessionID, snapshot.max_workers, dispatched, running, snapshot.tasks.length);
+                    parallelWorkerAlreadyBound = snapshot.tasks.some(({ phase, call_id, descriptor }) => phase === "running" && call_id === toolInput.callID &&
+                        sameParallelDescriptor(descriptor, reservedParallelDescriptor));
                     await coordinator.bindDispatch(toolInput.sessionID, toolInput.callID, reservedParallelDescriptor);
+                    const boundSnapshot = await coordinator.snapshot(toolInput.sessionID, reservedParallelDescriptor.run_id);
+                    if (boundSnapshot === undefined)
+                        throw new ParallelDispatchError("descriptor-mismatch", "Parallel run is absent.");
+                    const currentContribution = parallelWorkerAlreadyBound ? 0 : 1;
+                    const dispatched = boundSnapshot.tasks.filter(({ phase }) => phase === "running" || phase === "completed" || phase === "failed" || phase === "abandoned").length;
+                    const running = boundSnapshot.tasks.filter(({ phase }) => phase === "running").length;
+                    fastLane.enableParallelDispatch(toolInput.sessionID, boundSnapshot.max_workers, dispatched - currentContribution, running - currentContribution, boundSnapshot.tasks.length);
                     parallelWorkerAuthorized = true;
                 }
                 const resumedWorkerSessionID = fastLane.beforeTool(toolInput.sessionID, toolInput.tool, output.args, {
                     consultationFallbackAuthorized,
+                    parallelWorkerAlreadyBound,
                     parallelWorkerAuthorized,
                 });
                 if (resumedWorkerSessionID !== undefined) {
@@ -3413,8 +3543,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 if (eventSessionID !== undefined) {
                     const coordinator = await getParallelCoordinator().catch(() => undefined);
                     const owned = await coordinator?.snapshot(eventSessionID).catch(() => undefined);
-                    if (owned !== undefined)
-                        await coordinator?.cancel(eventSessionID, owned.run_id).catch(() => undefined);
+                    if (owned !== undefined) {
+                        const cancelled = await coordinator?.cancel(eventSessionID, owned.run_id).catch(() => undefined);
+                        if (cancelled !== undefined) {
+                            await Promise.all(owned.tasks.filter(({ phase }) => phase === "pending" || phase === "reserved")
+                                .map(({ descriptor }) => removeParallelControlFiles(descriptor).catch(() => undefined)));
+                        }
+                    }
                 }
                 evictSession(eventSessionID);
                 for (const role of [REVIEWER_AGENT, ADVISOR_AGENT]) {