sortie-dogs 0.3.14 → 0.3.16

package/README.md

@@ -12,15 +12,15 @@
 ![Sortie-dogs coordinating a bounded implementation workflow](https://raw.githubusercontent.com/zufall-upon/Sortie-dogs/main/docs/assets/sortie-workflow.gif)
 
 Sortie-dogs is an opt-in OpenCode orchestration plugin. It turns a task into a
-scoped plan, parallel investigation, dedicated implementation, canonical
+scoped plan, parallel investigation, bounded independent implementation, canonical
 validation, and evidence-backed completion—while preserving standard OpenCode
 agents and settings.
 
 Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
-Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md)
+Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.3.14](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.3.14)
+Release: [v0.3.16](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.3.16)
 
 ## Quick start
 
@@ -207,8 +207,10 @@ global file for durable global settings.
   exactly three bounded scouts before implementation begins.
 - **Writes stay inside the assignment.** Exact source or operation manifests
   gate edits and handoffs.
-- **One accountable implementation path.** One dedicated worker handles
-  implementation, remediation, and blocker resolution.
+- **Safe implementation fan-out.** Independent units may use two or three workers
+  with non-overlapping write manifests; dependent or same-path work stays on one worker.
+- **Runtime overlap protection.** Active equal or ancestor write scopes are rejected
+  before mutation, and full validation waits until every parallel unit joins.
 - **Evidence before completion.** Canonical validation, risk-based review, and
   terminal evidence gate coordinator-owned completion and commits.
 - **Long work can recover.** Restart recovery and bounded compaction continue

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.4-card36";
+export declare const RUNTIME_ASSET_VERSION = "0.3.4-card38";
 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.4-card36";
+export const RUNTIME_ASSET_VERSION = "0.3.4-card38";

package/dist/plugin/continuation.d.ts

@@ -20,6 +20,7 @@ export declare const CONTINUATION_MARKER = "<!-- SORTIE_CONTINUE -->";
 export declare const ROLLOVER_MARKER = "<!-- SORTIE_COMPACT -->";
 /** First token of the synthetic resume prompt, so the coordinator can recognize its own resume. */
 export declare const AUTO_CONTINUE_PREFIX = "SORTIE_AUTO_CONTINUE";
+export declare const STEP_CONTINUE_PREFIX = "SORTIE_STEP_CONTINUE";
 /** First line the rollover summary must emit, mirroring the batch target of three attempts. */
 export declare const ROLLOVER_TOKEN = "SORTIE_ROLLOVER_COMPACTED";
 export declare const DEFAULT_MAX_AUTO_CONTINUES = 2;

package/dist/plugin/continuation.js

@@ -20,6 +20,7 @@ export const CONTINUATION_MARKER = "<!-- SORTIE_CONTINUE -->";
 export const ROLLOVER_MARKER = "<!-- SORTIE_COMPACT -->";
 /** First token of the synthetic resume prompt, so the coordinator can recognize its own resume. */
 export const AUTO_CONTINUE_PREFIX = "SORTIE_AUTO_CONTINUE";
+export const STEP_CONTINUE_PREFIX = "SORTIE_STEP_CONTINUE";
 const TOOL_REQUESTED_REPORT = "Tool-requested Sortie rollover. Preserve task identity, both manifests, validation history, " +
     "batch counters, blocker state, and the exact next action from the latest messages.";
 /** First line the rollover summary must emit, mirroring the batch target of three attempts. */
@@ -32,6 +33,7 @@ export const DEFAULT_MAX_AUTO_CONTINUES = 2;
  */
 export const STEP_EXHAUSTED_PATTERN = /(?:最大step(?:s|数)?(?:に)?到達|step(?:s)?\s*(?:limit|budget)\s*(?:reached|exhausted)|maximum\s+steps?\s+reached)[\s\S]{0,2500}(?:残作業|未完了|未完|次action|next\s+action|remaining\s+work)/iu;
 const MAX_TRACKED_SESSIONS = 256;
+const MAX_STEP_CONTINUES_PER_TURN = 2;
 const DEFAULT_TIMINGS = {
     /** Compaction is expensive; one rollover per minute per session is the canonical ceiling. */
     cooldownMilliseconds: 60_000,
@@ -198,6 +200,8 @@ export function createContinuationHooks(client, directory, policySource, timings
             ownsHostContinuation: false,
             textCompleting: false,
             directUsed: false,
+            stepContinueCount: 0,
+            stepContinueIssuing: false,
             touched: Date.now(),
         };
         sessions.set(sessionID, created);
@@ -270,6 +274,47 @@ export function createContinuationHooks(client, directory, policySource, timings
         if (!promptCallSucceeded(resumed))
             throw new Error("resume request rejected");
     }
+    function nonTerminalProgress(text) {
+        if (text.startsWith(STEP_CONTINUE_PREFIX) || text.startsWith(AUTO_CONTINUE_PREFIX))
+            return false;
+        if (/\bstatus:\s*(?:DONE|BLOCKED|NEED_DECISION)\b/iu.test(text))
+            return false;
+        return /➡️\s*(?:次action|next_action)\s*:\s*\S/iu.test(text);
+    }
+    async function issueStepContinue(sessionID, state, report, agent) {
+        const resume = client?.session?.promptAsync;
+        const active = policy();
+        if (resume === undefined || !active.enabled || active.agent !== agent || state.stepContinueIssuing ||
+            state.stepContinueCount >= MAX_STEP_CONTINUES_PER_TURN)
+            return;
+        state.stepContinueIssuing = true;
+        state.stepContinueCount += 1;
+        state.latestCoordinatorReport = undefined;
+        try {
+            const resumed = await resume.call(client.session, {
+                path: { id: sessionID },
+                query: { directory },
+                body: {
+                    agent,
+                    parts: [{
+                            type: "text",
+                            synthetic: true,
+                            text: `${STEP_CONTINUE_PREFIX}\n直前出力は非terminal進捗。繰り返さず、同じcandidateのnext_actionを今すぐtoolで実行する。\n${report}`,
+                        }],
+                },
+            });
+            if (!promptCallSucceeded(resumed))
+                throw new Error("step continuation request rejected");
+        }
+        catch (error) {
+            state.stepContinueCount -= 1;
+            state.latestCoordinatorReport = report;
+            console.error("[sortie-continuation] step resume failed", sessionID, error);
+        }
+        finally {
+            state.stepContinueIssuing = false;
+        }
+    }
     /**
      * Single resume arbiter. Host events and timers may arrive in any order, but none of them may call
      * promptAsync directly. The epoch lock makes concurrent compacted/text/idle signals idempotent.
@@ -680,6 +725,7 @@ export function createContinuationHooks(client, directory, policySource, timings
             state.model = { providerID: model.providerID, modelID: model.modelID };
             state.turnRevision += 1;
             if (!synthetic) {
+                state.stepContinueCount = 0;
                 state.ownsHostContinuation = false;
                 state.limitCompacted = false;
             }
@@ -704,6 +750,18 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
         if (state?.pendingRollover === true) {
             await runRollover(sessionID);
+            return;
+        }
+        if (state !== undefined && !state.stepContinueIssuing &&
+            state.latestCoordinatorReport !== undefined &&
+            nonTerminalProgress(state.latestCoordinatorReport)) {
+            const report = state.latestCoordinatorReport;
+            const revision = state.turnRevision;
+            const identity = await readIdentity(sessionID);
+            const active = policy();
+            if (active.enabled && identity !== undefined && identity.agent === active.agent && !nonEmpty(identity.parentID) &&
+                state.turnRevision === revision && state.latestCoordinatorReport === report)
+                await issueStepContinue(sessionID, state, report, active.agent);
         }
     }
 }

package/dist/plugin/gate.d.ts

@@ -1,3 +1,4 @@
+import type { OperationManifest } from "../core/types.js";
 export interface ToolExecuteBeforeInput {
     tool: string;
     sessionID: string;
@@ -6,7 +7,7 @@ export interface ToolExecuteBeforeInput {
 export interface ToolExecuteBeforeOutput {
     args: unknown;
 }
-export type WriteDenialReason = "manifest-unavailable" | "session-expired" | "unclassified-command" | "path-required" | "project-boundary" | "manifest-scope" | "repeated-denial";
+export type WriteDenialReason = "manifest-unavailable" | "session-expired" | "unclassified-command" | "path-required" | "project-boundary" | "manifest-scope" | "parallel-git-mutation" | "parallel-remote-mutation" | "parallel-validation" | "session-released" | "repeated-denial";
 export declare class WriteDeniedError extends Error {
     readonly reason: WriteDenialReason;
     constructor(reason: WriteDenialReason, path: string, options?: ErrorOptions);
@@ -27,6 +28,8 @@ interface Extraction {
     ambiguous: boolean;
     paths: string[];
     gitCommit?: boolean;
+    gitMutation?: boolean;
+    remoteMutation?: boolean;
     issue?: CommandIssue;
 }
 interface CommandIssue {
@@ -42,6 +45,8 @@ export declare function resolveProjectRoot(input: {
 export declare function describeUnclassifiedCommand(tool: string, args: unknown): string | undefined;
 /** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
 export declare function extractWritePaths(tool: string, args: unknown): Extraction;
+export declare function isGitMutation(tool: string, args: unknown): boolean;
+export declare function isRemoteMutation(tool: string, args: unknown): boolean;
 /**
  * Quoted segments keep their contents; every unquoted whitespace run collapses to one space so the
  * same command written with different spacing compares equal.
@@ -49,6 +54,10 @@ export declare function extractWritePaths(tool: string, args: unknown): Extracti
 export declare function normalizeCommand(command: string): string;
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export declare function isKnownReadOnlyTool(tool: string, args: unknown, additionalReadOnlyTools?: ReadonlySet<string>): boolean;
+/** Canonical scopes let sibling worker bindings reject equal or ancestor ownership. */
+export declare function canonicalManifestWriteScopes(project: ProjectPaths, manifest: OperationManifest): Promise<readonly string[]>;
+export declare function canonicalManifestReadScopes(project: ProjectPaths, manifest: OperationManifest): Promise<readonly string[]>;
+export declare function writeScopesOverlap(left: readonly string[], right: readonly string[]): boolean;
 export declare function createProjectPaths(rootCandidate: string): Promise<ProjectPaths>;
 export declare function createWriteGate(project: ProjectPaths, value: unknown): Promise<WriteGate>;
 export {};

package/dist/plugin/gate.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve } from "node:path";
+import { basename, isAbsolute, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { RelativePathError, normalizeManifestPath, normalizeRelativePath } from "../core/path.js";
 import { validateOperationManifestSchema } from "../core/validate-schema.js";
@@ -14,6 +14,10 @@ export class WriteDeniedError extends Error {
             "path-required": "write path must be explicit.",
             "project-boundary": "project-root-relative path required.",
             "manifest-scope": "operation manifest write scope.",
+            "parallel-git-mutation": "parallel implementation workers cannot mutate shared Git state.",
+            "parallel-remote-mutation": "parallel implementation workers cannot mutate shared remote state.",
+            "parallel-validation": "parallel implementation validation must run after the worker join.",
+            "session-released": "released session must re-read only its handoff and bind before further work.",
             "repeated-denial": "same command and denial reason already denied in this session; retry blocked.",
         };
         super(`Write denied for "${safePath(path)}": ${messages[reason]}`, options);
@@ -131,6 +135,14 @@ function isRemoteOnlyGitHubCommand(tokens) {
     const command = tokens[1]?.toLowerCase();
     return command === "project" || (command === "api" && tokens[2]?.toLowerCase() === "graphql");
 }
+function isRemoteGitHubMutation(tokens) {
+    const command = tokens[1]?.toLowerCase();
+    if (command === "project") {
+        return !new Set(["field-list", "item-list", "list", "view"]).has(tokens[2]?.toLowerCase() ?? "");
+    }
+    // GraphQL transport can hide mutations in variables, files, or stdin; parallel workers fail closed.
+    return command === "api" && tokens[2]?.toLowerCase() === "graphql";
+}
 function isReadOnlyGitCommand(tokens) {
     const command = tokens[1]?.toLowerCase() ?? "";
     return READ_ONLY_GIT_COMMANDS.has(command) ||
@@ -226,9 +238,14 @@ function shellSegments(command, dialect) {
     for (let index = 0; index < masked.length; index += 1) {
         const character = masked[index];
         const pair = masked.slice(index, index + 2);
+        const segmentBefore = masked.slice(start, index).trim();
+        const hasCommandBefore = segmentBefore.length > 0;
+        const powershellCallOperator = dialect === "powershell" &&
+            (segmentBefore.length === 0 || segmentBefore.endsWith("="));
         const separator = pair === "&&" || pair === "||" ? 2
             : character === ";" || character === "\n" || character === "\r" ||
-                (character === "|" && command[index - 1] !== ">") ? 1 : 0;
+                (character === "|" && command[index - 1] !== ">") ||
+                (character === "&" && hasCommandBefore && command[index - 1] !== ">" && !powershellCallOperator) ? 1 : 0;
         if (separator === 0)
             continue;
         segments.push(command.slice(start, index));
@@ -252,6 +269,8 @@ function shellPaths(command, powershell, depth = 0) {
     let applies = false;
     let ambiguous = false;
     let gitCommit = false;
+    let gitMutation = false;
+    let remoteMutation = false;
     let issue;
     const redirection = /(?<![<>=!])(?:&|\d*)?(?:>>|>\||>)(?![=])/gu;
     const redirectionTarget = /^\s*("(?:\\.|[^"])*"|'[^']*'|&?\d+|[^\s;&|]+)/u;
@@ -344,6 +363,7 @@ function shellPaths(command, powershell, depth = 0) {
         }
         else if (executable === "git" && tokens[1]?.toLowerCase() === "add") {
             applies = true;
+            gitMutation = true;
             const selected = exactGitAddPaths(tokens);
             if (selected === undefined)
                 ambiguous = true;
@@ -352,6 +372,7 @@ function shellPaths(command, powershell, depth = 0) {
         }
         else if (executable === "git" && tokens[1]?.toLowerCase() === "commit") {
             applies = true;
+            gitMutation = true;
             if (isSafeGitCommit(tokens))
                 gitCommit = true;
             else
@@ -361,7 +382,8 @@ function shellPaths(command, powershell, depth = 0) {
             // Explicitly read-only git subcommands.
         }
         else if (/^gh(?:\.exe)?$/u.test(executable) && isRemoteOnlyGitHubCommand(tokens)) {
-            // GitHub Project commands mutate remote state, not project files. Redirections remain gated above.
+            // Remote operations are pathless, but parallel workers must distinguish reads from mutations.
+            remoteMutation ||= isRemoteGitHubMutation(tokens);
         }
         else if (depth === 0 && /^(?:pwsh|powershell)(?:\.exe)?$/u.test(executable)) {
             const literal = depthOnePowerShellLiteral(source);
@@ -376,6 +398,8 @@ function shellPaths(command, powershell, depth = 0) {
                 ambiguous ||= nested.ambiguous;
                 paths.push(...nested.paths);
                 gitCommit ||= nested.gitCommit === true;
+                gitMutation ||= nested.gitMutation === true;
+                remoteMutation ||= nested.remoteMutation === true;
                 issue ??= nested.issue;
             }
         }
@@ -385,7 +409,15 @@ function shellPaths(command, powershell, depth = 0) {
             issue ??= commandIssue(source, "executable-not-allowlisted", "use a direct allowlisted read-only command");
         }
     }
-    return { applies, ambiguous, paths, ...(gitCommit ? { gitCommit: true } : {}), ...(issue ? { issue } : {}) };
+    return {
+        applies,
+        ambiguous,
+        paths,
+        ...(gitCommit ? { gitCommit: true } : {}),
+        ...(gitMutation ? { gitMutation: true } : {}),
+        ...(remoteMutation ? { remoteMutation: true } : {}),
+        ...(issue ? { issue } : {}),
+    };
 }
 function issuePath(issue) {
     return `segment=${issue.segment}; cause=${issue.cause}; hint=${issue.hint}; retry=false; action=return-denial-to-coordinator`;
@@ -426,11 +458,19 @@ export function extractWritePaths(tool, args) {
             ambiguous: extracted.ambiguous,
             paths: [...paths, ...extracted.paths],
             ...(extracted.gitCommit ? { gitCommit: true } : {}),
+            ...(extracted.gitMutation ? { gitMutation: true } : {}),
+            ...(extracted.remoteMutation ? { remoteMutation: true } : {}),
             ...(extracted.issue ? { issue: extracted.issue } : {}),
         };
     }
     return { applies: false, ambiguous: false, paths: [] };
 }
+export function isGitMutation(tool, args) {
+    return extractWritePaths(tool, args).gitMutation === true;
+}
+export function isRemoteMutation(tool, args) {
+    return extractWritePaths(tool, args).remoteMutation === true;
+}
 /**
  * Quoted segments keep their contents; every unquoted whitespace run collapses to one space so the
  * same command written with different spacing compares equal.
@@ -492,6 +532,63 @@ async function nearestExistingRealPath(path) {
         return await realpath(candidate);
     }
 }
+function toggledCaseProbe(path) {
+    let candidate = resolve(path);
+    while (true) {
+        const name = basename(candidate);
+        const index = [...name].findIndex((character) => /[A-Za-z]/u.test(character));
+        if (index >= 0) {
+            const characters = [...name];
+            const character = characters[index];
+            characters[index] = character === character.toLowerCase()
+                ? character.toUpperCase()
+                : character.toLowerCase();
+            return {
+                original: candidate,
+                alternate: resolve(candidate, "..", characters.join("")),
+            };
+        }
+        const parent = resolve(candidate, "..");
+        if (parent === candidate)
+            return undefined;
+        candidate = parent;
+    }
+}
+async function isCaseInsensitivePath(path) {
+    if (process.platform === "win32")
+        return true;
+    const probe = toggledCaseProbe(path);
+    if (probe === undefined || probe.alternate === probe.original)
+        return false;
+    try {
+        return resolve(await realpath(probe.alternate)) === resolve(await realpath(probe.original));
+    }
+    catch {
+        return false;
+    }
+}
+async function canonicalPotentialPath(path) {
+    let candidate = resolve(path);
+    const missing = [];
+    while (true) {
+        try {
+            const realCandidate = await realpath(candidate);
+            const canonical = resolve(realCandidate, ...missing);
+            return await isCaseInsensitivePath(candidate)
+                ? canonical.toLowerCase()
+                : canonical;
+        }
+        catch (error) {
+            if (!isRecord(error) || error.code !== "ENOENT")
+                throw error;
+            const parent = resolve(candidate, "..");
+            if (parent === candidate)
+                throw error;
+            missing.unshift(basename(candidate));
+            candidate = parent;
+        }
+    }
+}
 async function isSymbolicLink(path) {
     try {
         return (await lstat(path)).isSymbolicLink();
@@ -506,6 +603,26 @@ function isWithin(root, target) {
     const path = relative(root, target);
     return path === "" || (!path.startsWith("..") && !isAbsolute(path));
 }
+async function canonicalManifestScopes(project, entries) {
+    const scopes = await Promise.all(entries.map(async (entry) => {
+        const normalized = normalizeManifestPath(entry);
+        const absolute = normalized.kind === "relative"
+            ? project.absolute(normalized.path)
+            : resolve(normalized.path);
+        return await canonicalPotentialPath(absolute);
+    }));
+    return [...new Set(scopes)];
+}
+/** Canonical scopes let sibling worker bindings reject equal or ancestor ownership. */
+export async function canonicalManifestWriteScopes(project, manifest) {
+    return await canonicalManifestScopes(project, manifest.write);
+}
+export async function canonicalManifestReadScopes(project, manifest) {
+    return await canonicalManifestScopes(project, manifest.read);
+}
+export function writeScopesOverlap(left, right) {
+    return left.some((leftPath) => right.some((rightPath) => isWithin(leftPath, rightPath) || isWithin(rightPath, leftPath)));
+}
 export async function createProjectPaths(rootCandidate) {
     const root = resolve(rootCandidate);
     const realRoot = await realpath(root);