sortie-dogs 0.5.10 → 0.5.13

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.10](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.10)
+Release: [v0.5.13](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.13)
 
 ## Quick start
 
@@ -164,13 +164,19 @@ options. OpenCode plugin normalization may omit factory options, so use the
 global file for durable global settings.
 
 - `operationManifestPath` moves the manifest; the path is project-relative.
-- `handoffPaths` lists the handoff files the plugin inspects. A worker can only
+- `handoffPaths` lists the handoff files the plugin inspects. A worker can only
   bind after one of these files passes inspection, so an empty list disables
   binding entirely. Relative entries are also candidate-relative in a nested
   repository: a child candidate may use its own `handoff.json` while OpenCode is
   opened at the parent workspace. For operational work the coordinator creates
   that valid handoff before dispatch and sends its exact absolute path; the
-  binding child must use the built-in Read tool on it immediately before bind.
+  binding child must use the built-in Read tool on it immediately before bind.
+  New coordinator contracts are emitted under the candidate-relative
+  `.sortie-dogs/contracts/` directory as `handoff.<id>.json` and
+  `<id>.operation-manifest.json`. The directory is ignored by this repository's
+  `.gitignore`; legacy root/scoped paths and configured custom paths remain
+  readable and preflight-compatible, but are never moved or deleted.
+  Remove the directory only when no Sortie run is active.
 - `readOnlyTools` adds host-specific tool names that never change files, such as
   MCP tools. Unknown tools are denied for a bound session by default.
 - `dedicatedWorkerModel` selects the single model every worker role resolves to.

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.44-command-reauthorization-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.47-autonomous-recovery-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.44-command-reauthorization-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.47-autonomous-recovery-v1";

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

@@ -749,6 +749,8 @@ async function status(context, staged) {
     const controls = new Set([
         `handoff.${context.descriptor.task_id}.json`,
         `${context.descriptor.task_id}.operation-manifest.json`,
+        `.sortie-dogs/contracts/handoff.${context.descriptor.task_id}.json`,
+        `.sortie-dogs/contracts/${context.descriptor.task_id}.operation-manifest.json`,
     ]);
     return entries.filter(({ code, path }) => code !== "A" || !controls.has(path));
 }

package/dist/plugin/continuation.js

@@ -33,8 +33,6 @@ export const DEFAULT_MAX_AUTO_CONTINUES = 10;
  */
 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_SEGMENT = 2;
-const MAX_STEP_CONTINUES_PER_TURN = 4;
 const DEFAULT_TIMINGS = {
     /** Compaction is expensive; one rollover per minute per session is the canonical ceiling. */
     cooldownMilliseconds: 60_000,
@@ -271,9 +269,8 @@ export function createContinuationHooks(client, directory, policySource, timings
             resumeAttempts: 0,
             textCompleting: false,
             directUsed: false,
-            stepContinueCount: 0,
-            stepContinueTotal: 0,
             stepContinueIssuing: false,
+            stepRecoveryActive: false,
             touched: Date.now(),
         };
         sessions.set(sessionID, created);
@@ -350,8 +347,53 @@ export function createContinuationHooks(client, directory, policySource, timings
         if (!promptCallSucceeded(resumed))
             throw new Error("resume request rejected");
     }
+    function topLevelProtocolLines(text) {
+        const lines = [];
+        let fence;
+        for (const [index, line] of text.split(/\r?\n/u).entries()) {
+            if (fence === undefined) {
+                const opener = /^[ \t]*(`{3,}|~{3,})/u.exec(line)?.[1];
+                if (opener === undefined) {
+                    if (!/^[ \t]*>/u.test(line))
+                        lines.push({ index, line });
+                    continue;
+                }
+                fence = { character: opener[0], length: opener.length };
+                continue;
+            }
+            const closer = /^[ \t]*(`{3,}|~{3,})[ \t]*$/u.exec(line)?.[1];
+            if (closer?.[0] === fence.character && closer.length >= fence.length)
+                fence = undefined;
+        }
+        return lines;
+    }
+    function checkpointEntries(text) {
+        const entries = [];
+        for (const { index, line } of topLevelProtocolLines(text)) {
+            const explicit = /^status:\s*(DONE|BLOCKED|NEED_DECISION)\b/iu.exec(line)?.[1]?.toUpperCase();
+            const status = explicit ??
+                (/^✅[ \t]+\*\*DONE\*\*/u.test(line) ? "DONE" :
+                    /^⛔[ \t]+\*\*BLOCKED\*\*/u.test(line) ? "BLOCKED" :
+                        /^❓[ \t]+\*\*NEED_DECISION\*\*/u.test(line) ? "NEED_DECISION" : undefined);
+            if (status === "DONE" || status === "BLOCKED" || status === "NEED_DECISION") {
+                entries.push({ index, status });
+            }
+        }
+        return entries;
+    }
+    function checkpointStatus(text) {
+        return checkpointEntries(text).at(-1)?.status;
+    }
     function terminalCheckpoint(text) {
-        return /\bstatus:\s*(?:DONE|BLOCKED|NEED_DECISION)\b/iu.test(text);
+        const status = checkpointStatus(text);
+        return status === "DONE" || status === "NEED_DECISION" || (status === "BLOCKED" && trueBlockerReport(text));
+    }
+    function trueBlockerReport(text) {
+        const checkpoint = checkpointEntries(text).at(-1);
+        if (checkpoint?.status !== "BLOCKED")
+            return false;
+        return topLevelProtocolLines(text).some(({ line, index }) => index > checkpoint.index &&
+            /^TRUE_BLOCKER\s*:\s*(?:external|user-decision)\s*:\s*\S.*$/u.test(line));
     }
     function latestProgressLine(text) {
         return text.split(/\r?\n/u).filter((line) => line.includes("📊")).at(-1);
@@ -382,19 +424,23 @@ export function createContinuationHooks(client, directory, policySource, timings
             return false;
         if (/➡️\s*(?:次action|next_action)\s*:\s*\S/iu.test(text))
             return true;
+        if (checkpointStatus(text) === "BLOCKED" && !trueBlockerReport(text))
+            return true;
         const percent = latestProgressPercent(text);
-        return percent !== undefined && (percent < 100 || batchHasIndependentRemainder(text));
+        if (percent !== undefined)
+            return percent < 100 || batchHasIndependentRemainder(text);
+        // Coordinators sometimes omit the optional percentage while retaining a localized progress label.
+        return /📊\s*(?:進行中|处理中|in[ -]?progress)(?:\s|[:：]|$)/iu.test(latestProgressLine(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_SEGMENT ||
-            state.stepContinueTotal >= MAX_STEP_CONTINUES_PER_TURN)
+            (state.lastStepContinueRevision === state.turnRevision && state.lastStepContinueReport === report))
             return;
+        const revision = state.turnRevision;
         state.stepContinueIssuing = true;
-        state.stepContinueCount += 1;
-        state.stepContinueTotal += 1;
+        state.stepRecoveryActive = true;
         state.latestCoordinatorReport = undefined;
         try {
             const resumed = await resume.call(client.session, {
@@ -405,21 +451,26 @@ export function createContinuationHooks(client, directory, policySource, timings
                     parts: [{
                             type: "text",
                             synthetic: true,
-                            text: `${STEP_CONTINUE_PREFIX}\n直前出力は非terminal進捗。進捗報告を繰り返さず、明示next_actionが欠落していれば最新の未達user要求とbatch counterから次の必要toolを特定して同じturnで実行する。\n${report}`,
+                            text: `${STEP_CONTINUE_PREFIX}\n直前出力は非terminal進捗またはlocal/process blocker。未達のuser order、sequential execution、no-stop制約、SOL/advisor consultation指示を保持し、interactionは真にuser-controlledな決定だけに限定する。local gate/routing/handoff/scope/retry/time/step defectはterminal reportにせず、自律修復・redispatchして継続する。進捗報告を繰り返さず、明示next_actionが欠落していれば最新の未達user要求とbatch counterから次の必要toolを特定して同じturnで実行する。\n${report}`,
                         }],
                 },
             });
             if (!promptCallSucceeded(resumed))
                 throw new Error("step continuation request rejected");
+            state.lastStepContinueReport = report;
+            state.lastStepContinueRevision = revision;
         }
         catch (error) {
-            state.stepContinueCount -= 1;
-            state.stepContinueTotal -= 1;
+            state.stepRecoveryActive = false;
             state.latestCoordinatorReport = report;
             console.error("[sortie-continuation] step resume failed", sessionID, error);
         }
         finally {
             state.stepContinueIssuing = false;
+            if (sessions.get(sessionID) === state && state.stepRecoveryActive &&
+                state.latestCoordinatorReport !== undefined && !terminalCheckpoint(state.latestCoordinatorReport)) {
+                queueMicrotask(() => { void handleSessionIdle(sessionID); });
+            }
         }
     }
     /**
@@ -453,9 +504,6 @@ export function createContinuationHooks(client, directory, policySource, timings
             state.continueReport = undefined;
             state.preserveCompactionScope = false;
             state.recoverySummaryValidated = false;
-            // A successful rollover starts a new bounded context segment. Keep ordinary synthetic turns
-            // from resetting this guard, but allow two fresh progress recoveries after compaction.
-            state.stepContinueCount = 0;
             // The accepted prompt now belongs to the host loop, not this rollover request.
             state.active = false;
             return true;
@@ -615,6 +663,7 @@ export function createContinuationHooks(client, directory, policySource, timings
         state.recoverySummaryValidated = false;
         state.resetAttemptsAfterCompaction = resetAttemptsAfterCompaction;
         state.latestCoordinatorReport = undefined;
+        state.stepRecoveryActive = false;
         if (resume)
             state.attempts += 1;
         const epoch = state.rolloverEpoch;
@@ -763,6 +812,11 @@ export function createContinuationHooks(client, directory, policySource, timings
                     trimmed.length > 0 && !trimmed.startsWith(ROLLOVER_TOKEN) &&
                     !trimmed.startsWith(AUTO_CONTINUE_PREFIX)) {
                     state.latestCoordinatorReport = output.text.trim();
+                    if (terminalCheckpoint(state.latestCoordinatorReport)) {
+                        state.stepRecoveryActive = false;
+                        clearTimer(state.stepRecoveryTimer);
+                        state.stepRecoveryTimer = undefined;
+                    }
                     if (batchCheckpointNeedsContinuation(state.latestCoordinatorReport)) {
                         if (input.allowCheckpointContinuation === false) {
                             state.latestCoordinatorReport = undefined;
@@ -775,7 +829,8 @@ export function createContinuationHooks(client, directory, policySource, timings
                             await requestContinuation(input.sessionID, identity, report, true);
                         }
                     }
-                    else if (nonTerminalProgress(state.latestCoordinatorReport)) {
+                    else if (nonTerminalProgress(state.latestCoordinatorReport) ||
+                        (state.stepRecoveryActive && !terminalCheckpoint(state.latestCoordinatorReport))) {
                         scheduleStepRecovery(input.sessionID, state, state.latestCoordinatorReport);
                     }
                     // The resumed coordinator completed a turn, so no late event from its prior compaction can
@@ -892,14 +947,16 @@ export function createContinuationHooks(client, directory, policySource, timings
                 state.attempts = 0;
             state.directUsed = false;
             state.latestCoordinatorReport = undefined;
+            if (!synthetic) {
+                state.lastStepContinueReport = undefined;
+                state.lastStepContinueRevision = undefined;
+                state.stepRecoveryActive = false;
+            }
             state.compactingEpoch = undefined;
             state.model = { providerID: model.providerID, modelID: model.modelID };
             state.turnRevision += 1;
-            if (!synthetic) {
-                state.stepContinueCount = 0;
-                state.stepContinueTotal = 0;
+            if (!synthetic)
                 state.limitCompacted = false;
-            }
         },
         blocksTool(sessionID) {
             const state = sessions.get(sessionID);
@@ -925,7 +982,8 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
         if (state !== undefined && !state.stepContinueIssuing &&
             state.latestCoordinatorReport !== undefined &&
-            nonTerminalProgress(state.latestCoordinatorReport)) {
+            (nonTerminalProgress(state.latestCoordinatorReport) ||
+                (state.stepRecoveryActive && !terminalCheckpoint(state.latestCoordinatorReport)))) {
             const report = state.latestCoordinatorReport;
             const revision = state.turnRevision;
             const identity = await readIdentity(sessionID);

package/dist/plugin/gate.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve, win32 } from "node:path";
 import { promisify } from "node:util";
 import { RelativePathError, normalizeManifestPath, normalizeRelativePath } from "../core/path.js";
 import { validateOperationManifestSchema } from "../core/validate-schema.js";
@@ -377,6 +377,22 @@ function depthOnePowerShellLiteral(source) {
 function commandIssue(segment, cause, hint) {
     return { segment: segment.trim().slice(0, 240), cause, hint };
 }
+function isLiteralPowerShellPath(value) {
+    return value.length > 0 && !/[\u0000-\u001f\u007f$*?\[\]@(){},;|&`<>]/u.test(value);
+}
+function robocopyOutput(tokens) {
+    if (tokens.length !== 4)
+        return undefined;
+    const source = tokens[1];
+    const destination = tokens[2];
+    const file = tokens[3];
+    const literal = (value) => value.length > 0 && !/[\u0000-\u001f\u007f$*?]/u.test(value);
+    if (!literal(source) || !literal(destination) || !literal(file) ||
+        file === "." || file === ".." || /[\\/]/u.test(file) ||
+        source.startsWith("/") || destination.startsWith("/") || file.startsWith("/"))
+        return undefined;
+    return win32.join(destination, file);
+}
 function shellPaths(command, powershell, depth = 0) {
     const paths = [];
     let applies = false;
@@ -486,6 +502,18 @@ function shellPaths(command, powershell, depth = 0) {
             if (destination !== undefined)
                 requiredDirectories.push(dirname(destination));
         }
+        else if (/^robocopy(?:\.exe)?$/u.test(executable)) {
+            applies = true;
+            const destination = robocopyOutput(tokens);
+            if (destination === undefined) {
+                ambiguous = true;
+                issue ??= commandIssue(source, "unsupported-robocopy-form", "use literal Robocopy.exe <source-dir> <destination-dir> <single-file>");
+            }
+            else {
+                paths.push(destination);
+                requiredDirectories.push(dirname(destination));
+            }
+        }
         else if (executable === "tar") {
             const mode = tarMode(tokens);
             if (mode === undefined) {
@@ -502,6 +530,68 @@ function shellPaths(command, powershell, depth = 0) {
         else if (executable === "find" && isDirectFindHash(tokens)) {
             // Exact member lookup plus sha256sum is read-only; a following tee owns any output path.
         }
+        else if (executable === "copy-item") {
+            applies = true;
+            const destinations = [];
+            const sources = [];
+            const positional = [];
+            let unsupported = false;
+            let force = false;
+            for (let index = 1; index < tokens.length; index += 1) {
+                const token = tokens[index];
+                if (/^-(?:path|literalpath)$/iu.test(token)) {
+                    const candidate = tokens[index + 1];
+                    if (candidate !== undefined && !candidate.startsWith("-"))
+                        sources.push(candidate);
+                    else
+                        unsupported = true;
+                    index += 1;
+                }
+                else if (/^-destination$/iu.test(token)) {
+                    const candidate = tokens[index + 1];
+                    if (candidate !== undefined && !candidate.startsWith("-"))
+                        destinations.push(candidate);
+                    else
+                        unsupported = true;
+                    index += 1;
+                }
+                else if (/^-force$/iu.test(token)) {
+                    if (force)
+                        unsupported = true;
+                    force = true;
+                }
+                else if (token.startsWith("-")) {
+                    unsupported = true;
+                }
+                else if (!token.startsWith("-")) {
+                    positional.push(token);
+                }
+            }
+            const namedForm = sources.length === 1 && destinations.length === 1 && positional.length === 0;
+            const namedSourceForm = sources.length === 1 && destinations.length === 0 && positional.length === 1;
+            const namedDestinationForm = sources.length === 0 && destinations.length === 1 && positional.length === 1;
+            const positionalForm = sources.length === 0 && destinations.length === 0 && positional.length === 2;
+            const copySource = namedForm || namedSourceForm
+                ? sources[0]
+                : namedDestinationForm || positionalForm
+                    ? positional[0]
+                    : undefined;
+            const destination = namedForm || namedDestinationForm
+                ? destinations[0]
+                : namedSourceForm || positionalForm
+                    ? positional.at(-1)
+                    : undefined;
+            if (unsupported
+                || copySource === undefined
+                || destination === undefined
+                || !isLiteralPowerShellPath(copySource)
+                || !isLiteralPowerShellPath(destination)) {
+                ambiguous = true;
+                issue ??= commandIssue(source, "unsupported-copy-item-form", "use one literal source, one literal destination, and optional -Force");
+            }
+            else
+                paths.push(destination);
+        }
         else if (POWERSHELL_WRITE_COMMANDS.has(executable)) {
             applies = true;
             const named = [];
@@ -885,6 +975,9 @@ export async function createWriteGate(project, value) {
     catch (error) {
         throw new WriteDeniedError("manifest-unavailable", "<unknown>", { cause: error });
     }
+    // A missing relative descendant is a directory scope when its parent is also declared.
+    // This authorizes files below the bounded child without widening the parent declaration.
+    const inferredDirectories = new Set([...writable].filter((candidate) => [...writable].some((other) => other !== candidate && candidate.startsWith(`${other}/`))));
     const writableDirectories = [];
     for (const path of writable) {
         try {
@@ -894,7 +987,8 @@ export async function createWriteGate(project, value) {
             }
         }
         catch (error) {
-            if (declaredDirectories.has(path) && isRecord(error) && error.code === "ENOENT") {
+            if ((declaredDirectories.has(path) || inferredDirectories.has(path)) &&
+                isRecord(error) && error.code === "ENOENT") {
                 writableDirectories.push({ path, realPath: await nearestExistingRealPath(project.absolute(path)) });
             }
             // Other missing, inaccessible, and concurrently changed paths remain exact-only scopes.