sortie-dogs 0.5.15 → 0.5.17

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.15](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.15)
+Release: [v0.5.17](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.5.17)
 
 ## Quick start
 

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

@@ -13,6 +13,7 @@ const MAX_OUTPUT = 1024 * 1024;
 const MAX_TIMEOUT = 10 * 60_000;
 const GIT_TIMEOUT = 30_000;
 const EXIT_GRACE = 500;
+let systemdUnitSequence = 0;
 const KILL_WAIT = 2_000;
 const WINDOWS_WRAPPER_GRACE = 15_000;
 const LINUX_WRAPPER_GRACE = 10_000;
@@ -483,9 +484,163 @@ async function terminateTree(child, closed) {
             return false;
         };
         if (!(await groupGone())) {
-            throw new WorktreeCommitArtifactError("validation-failed", "Process-tree termination could not be confirmed.");
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch { /* Already closed. */ }
+            if (!(await groupGone())) {
+                throw new WorktreeCommitArtifactError("validation-failed", "Process-tree termination could not be confirmed.");
+            }
+        }
+    }
+}
+async function linuxSystemdRun() {
+    for (const candidate of ["/usr/bin/systemd-run", "/bin/systemd-run"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxSystemctl() {
+    for (const candidate of ["/usr/bin/systemctl", "/bin/systemctl"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxEnvironmentExecutable() {
+    for (const candidate of ["/usr/bin/env", "/bin/env"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function linuxShell() {
+    for (const candidate of ["/bin/sh", "/usr/bin/sh"]) {
+        const canonical = await realpath(candidate).catch(() => undefined);
+        if (canonical === undefined || !canonical.startsWith("/usr/bin/") && !canonical.startsWith("/bin/"))
+            continue;
+        const info = await lstat(canonical).catch(() => undefined);
+        if (info !== undefined && info.isFile() && !info.isSymbolicLink() && info.uid === 0 && (info.mode & 0o111) !== 0)
+            return canonical;
+    }
+    throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+}
+async function stopSystemdUnit(unit, environment) {
+    const systemctl = await linuxSystemctl();
+    const invoke = async (args) => {
+        const child = spawn(systemctl, args, { env: environment, shell: false, windowsHide: true, stdio: "ignore" });
+        const closed = new Promise((done, reject) => {
+            child.once("error", reject);
+            child.once("close", (code) => done({ code }));
+        });
+        if (!(await waitForClose(closed, KILL_WAIT + 1_500))) {
+            child.kill("SIGKILL");
+            if (!(await waitForClose(closed, KILL_WAIT))) {
+                throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+            }
         }
+        return (await closed).code;
+    };
+    await invoke(["--user", "stop", unit]).catch(() => undefined);
+    const activeState = async () => {
+        const code = await invoke(["--user", "is-active", "--quiet", unit]);
+        if (code === 0)
+            return true;
+        if (code === 3 || code === 4)
+            return false;
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+    };
+    const deadline = Date.now() + KILL_WAIT;
+    while (Date.now() < deadline) {
+        if (await activeState()) {
+            await invoke(["--user", "stop", unit]).catch(() => undefined);
+        }
+        await new Promise((done) => setTimeout(done, 25));
+    }
+    if (await activeState()) {
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment shutdown failed.");
+    }
+}
+async function runLinuxSystemd(executable, args, cwd, timeout) {
+    const systemdRun = await linuxSystemdRun();
+    const [environmentExecutable, shell] = await Promise.all([linuxEnvironmentExecutable(), linuxShell()]);
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation containment setup failed.");
+    const runtimeDirectory = `/run/user/${uid}`;
+    const environment = {
+        ...cleanEnvironment(),
+        XDG_RUNTIME_DIR: runtimeDirectory,
+        DBUS_SESSION_BUS_ADDRESS: `unix:path=${runtimeDirectory}/bus`,
+    };
+    systemdUnitSequence = (systemdUnitSequence + 1) % Number.MAX_SAFE_INTEGER;
+    const unit = `sortie-dogs-${process.pid}-${Date.now()}-${systemdUnitSequence}`;
+    const validationEnvironment = Object.entries(cleanEnvironment()).map(([key, value]) => `${key}=${value}`);
+    const child = spawn(systemdRun, [
+        "--user", "--wait", "--collect", "--quiet", `--unit=${unit}`,
+        "--property=KillMode=control-group", `--property=RuntimeMaxSec=${timeout}ms`,
+        "--property=TimeoutStopSec=1s", "--working-directory", cwd, "--",
+        environmentExecutable, "-i", ...validationEnvironment, shell, "-c",
+        '"$@"; code=$?; if [ "$code" -eq 0 ]; then exit 0; else exit 239; fi',
+        "sortie-validation", executable, ...args,
+    ], {
+        cwd, env: environment, shell: false, windowsHide: true, detached: true, stdio: ["ignore", "pipe", "pipe"],
+    });
+    const chunks = [];
+    let outputBytes = 0;
+    let overflow = false;
+    const collect = (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes <= MAX_OUTPUT)
+            chunks.push(chunk);
+        else
+            overflow = true;
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes > MAX_OUTPUT)
+            overflow = true;
+    });
+    const closed = new Promise((done, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => done({ code }));
+    });
+    let timer;
+    const bounded = await Promise.race([
+        closed.then((result) => ({ kind: "closed", result })),
+        new Promise((done) => {
+            timer = setTimeout(() => done({ kind: "timeout" }), timeout + LINUX_WRAPPER_GRACE);
+        }),
+    ]).catch(async () => {
+        await terminateTree(child, closed).catch(() => undefined);
+        await stopSystemdUnit(unit, environment);
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation executable failed.");
+    });
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (bounded.kind === "timeout" || overflow) {
+        if (child.exitCode === null && child.signalCode === null)
+            await terminateTree(child, closed);
+        await stopSystemdUnit(unit, environment);
+        throw new WorktreeCommitArtifactError("validation-failed", "Validation exceeded its resource bound.");
     }
+    await stopSystemdUnit(unit, environment);
+    const code = bounded.result.code === 0 ? 0 : bounded.result.code === 1 ? 238 : 239;
+    return { code, stdout: Buffer.concat(chunks) };
 }
 async function runBounded(executable, args, cwd, timeout, kind) {
     const windowsWrapper = kind === "validation" && process.platform === "win32";
@@ -557,6 +712,8 @@ async function runBounded(executable, args, cwd, timeout, kind) {
         }
         const code = linuxWrapper && result.code !== 0 && ![238, 239, 240, 241].includes(result.code ?? -1)
             ? 240 : result.code ?? -1;
+        if (linuxWrapper && code === 240)
+            return await runLinuxSystemd(executable, args, cwd, timeout);
         return { code, stdout: Buffer.concat(chunks) };
     }
     catch (error) {

package/dist/plugin/continuation.d.ts

@@ -144,6 +144,7 @@ export interface ContinuationHooks {
     textComplete(input: {
         sessionID: string;
         allowCheckpointContinuation?: boolean;
+        allowStepRecoveryFallback?: boolean;
     }, output: {
         text: string;
     }): Promise<void>;

package/dist/plugin/continuation.js

@@ -865,7 +865,9 @@ export function createContinuationHooks(client, directory, policySource, timings
                     }
                     else if (nonTerminalProgress(state.latestCoordinatorReport) ||
                         (state.stepRecoveryActive && !terminalCheckpoint(state.latestCoordinatorReport))) {
-                        scheduleStepRecovery(input.sessionID, state, state.latestCoordinatorReport);
+                        if (input.allowStepRecoveryFallback !== false) {
+                            scheduleStepRecovery(input.sessionID, state, state.latestCoordinatorReport);
+                        }
                     }
                     // The resumed coordinator completed a turn, so no late event from its prior compaction can
                     // compete with the next host-managed compaction.

package/dist/plugin/index.js

@@ -919,6 +919,7 @@ export const SortieDogsPlugin = async (input, options) => {
         return loaded?.gate === undefined && manifestAbsent;
     }
     const inspected = new Map();
+    const inspectionOperations = new Map();
     const sessionAuthorizations = new Map();
     const bindingPins = new Map();
     const bindingOperations = new Set();
@@ -1383,8 +1384,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 if (JSON.stringify(running.artifact.validation.command) !== JSON.stringify(requestedCommand)) {
                     return deny("artifact-replay");
                 }
-                await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, running.artifact);
                 await removeParallelControlFiles(binding.descriptor);
+                await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, running.artifact);
                 parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact: running.artifact });
                 pruneParallelChildMap(parallelArtifacts);
                 return JSON.stringify({ status: "created", replay: true, artifact: boundedParallelArtifact(running.artifact) });
@@ -1397,8 +1398,8 @@ 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);
+            await (await getParallelCoordinator()).acceptArtifact(binding.ownerRoot, binding.completionCallID, sessionID, binding.descriptor, artifact);
             parallelArtifacts.set(sessionID, { requestFingerprint: request.fingerprint, artifact });
             pruneParallelChildMap(parallelArtifacts);
             return JSON.stringify({ status: "created", ...(recovered === undefined ? {} : { replay: true }),
@@ -1564,13 +1565,14 @@ export const SortieDogsPlugin = async (input, options) => {
             authorization.lease = undefined;
         }
     }
-    async function completeContinuationText(sessionID, text) {
+    async function completeContinuationText(sessionID, text, allowStepRecoveryFallback = true) {
         const continuationText = fastLane.manualCompactionForbidden(sessionID)
             ? text.replaceAll(ROLLOVER_MARKER, "").replaceAll(CONTINUATION_MARKER, "").trimEnd()
             : text;
         await continuation.textComplete({
             sessionID,
             allowCheckpointContinuation: fastLane.backlogContinuationAllowed(sessionID),
+            allowStepRecoveryFallback,
         }, { text: continuationText });
         if (fastLane.backlogContinuationAllowed(sessionID) && continuation.blocksTool(sessionID)) {
             fastLane.continuationQueued(sessionID);
@@ -1952,6 +1954,11 @@ export const SortieDogsPlugin = async (input, options) => {
                     return deny("binding-replay");
             }
             const existingAuthorization = sessionAuthorizations.get(sessionID);
+            const pendingInspections = [...inspectionOperations.entries()]
+                .filter(([key]) => key.startsWith(`${sessionID}\u0000`))
+                .map(([, operation]) => operation);
+            if (pendingInspections.length > 0)
+                await Promise.allSettled(pendingInspections);
             pruneInspections(now);
             const inspectedEntry = [...inspected.entries()].find(([key, entry]) => key.startsWith(`${sessionID}\u0000`) &&
                 entry.ownerSessionID === sessionID &&
@@ -2400,7 +2407,17 @@ export const SortieDogsPlugin = async (input, options) => {
         const path = input.args.filePath;
         if (typeof path !== "string" || path.length === 0)
             return;
-        await inspect(path, input.sessionID);
+        const absolutePath = resolve(path);
+        const key = `${input.sessionID}\u0000${absolutePath}`;
+        const operation = inspect(path, input.sessionID).then(() => undefined);
+        inspectionOperations.set(key, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (inspectionOperations.get(key) === operation)
+                inspectionOperations.delete(key);
+        }
     }
     async function invalidateEditedHandoff(path) {
         await ensureLoaded();
@@ -2481,7 +2498,7 @@ export const SortieDogsPlugin = async (input, options) => {
             return undefined;
         }
     }
-    async function hostSessionUserTurn(sessionID) {
+    async function hostSessionRecoveryHistory(sessionID) {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
             return undefined;
@@ -2493,55 +2510,40 @@ export const SortieDogsPlugin = async (input, options) => {
             const payload = isRecord(response) && "data" in response ? response.data : response;
             if (!Array.isArray(payload))
                 return undefined;
+            let persistedTurn;
+            let hasForeignUserTurn = false;
             for (let index = payload.length - 1; index >= 0; index -= 1) {
                 const message = payload[index];
-                if ((message.info?.role ?? message.role) !== "user")
-                    continue;
-                const agent = message.info?.agent ?? message.agent;
-                if (typeof agent !== "string")
+                if (!isRecord(message))
                     return undefined;
-                return {
-                    agent,
-                    synthetic: (message.parts ?? []).some((part) => part.synthetic === true),
-                };
-            }
-            return undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async function hostSessionForeignUserAgent(sessionID) {
-        const messages = input.client?.session?.messages;
-        if (messages === undefined)
-            return undefined;
-        try {
-            const response = await messages.call(input.client.session, {
-                path: { id: sessionID },
-                query: { directory: input.directory },
-            });
-            const payload = isRecord(response) && "data" in response ? response.data : response;
-            if (!Array.isArray(payload))
-                return undefined;
-            for (const message of payload) {
-                if ((message.info?.role ?? message.role) !== "user")
+                if (message.info !== undefined && !isRecord(message.info))
+                    return undefined;
+                const info = isRecord(message.info) ? message.info : undefined;
+                const role = info?.role ?? message.role;
+                if (role !== "user" && role !== "assistant")
+                    return undefined;
+                if (role !== "user")
                     continue;
-                const agent = message.info?.agent ?? message.agent;
+                const agent = info?.agent ?? message.agent;
                 if (typeof agent !== "string")
                     return undefined;
                 if (agent !== COORDINATOR_AGENT)
-                    return agent;
+                    hasForeignUserTurn = true;
+                if (persistedTurn === undefined) {
+                    if (message.parts !== undefined && !Array.isArray(message.parts))
+                        return undefined;
+                    persistedTurn = {
+                        agent,
+                        synthetic: Array.isArray(message.parts) && message.parts.some((part) => isRecord(part) && part.synthetic === true),
+                    };
+                }
             }
-            return false;
+            return { hasForeignUserTurn, persistedTurn };
         }
         catch {
             return undefined;
         }
     }
-    async function hostSessionHasForeignUserTurn(sessionID) {
-        const agent = await hostSessionForeignUserAgent(sessionID);
-        return typeof agent === "string" ? true : agent;
-    }
     async function assistantMessageText(sessionID, messageID, expectedAgent, partID) {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
@@ -2599,10 +2601,13 @@ export const SortieDogsPlugin = async (input, options) => {
             return false;
         if (identity.agent !== undefined && identity.agent !== COORDINATOR_AGENT)
             return false;
-        if (await hostSessionHasForeignUserTurn(sessionID) !== false)
+        const history = await hostSessionRecoveryHistory(sessionID);
+        if (history === undefined || history.hasForeignUserTurn)
+            return false;
+        const persistedTurn = history.persistedTurn;
+        if (persistedTurn === undefined && identity.agent !== COORDINATOR_AGENT)
             return false;
-        const persistedTurn = await hostSessionUserTurn(sessionID);
-        if (persistedTurn?.agent !== COORDINATOR_AGENT)
+        if (persistedTurn !== undefined && persistedTurn.agent !== COORDINATOR_AGENT)
             return false;
         await rememberCoordinatorRoot(sessionID);
         releaseSessionEnforcement(sessionID);
@@ -2898,7 +2903,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     .replaceAll(CONTINUATION_MARKER, "")
                     .trimEnd();
             }
-            await completeContinuationText(textInput.sessionID, textOutput.text);
+            await completeContinuationText(textInput.sessionID, textOutput.text, false);
         },
         "experimental.session.compacting": async (compactInput, compactOutput) => {
             await continuation.sessionCompacting(compactInput, compactOutput);
@@ -3101,6 +3106,7 @@ export const SortieDogsPlugin = async (input, options) => {
          */
         "tool.execute.after": async (toolInput, output) => {
             const completedChildSessionID = toolInput.tool === "task" ? taskChildSessionID(output) : undefined;
+            const handoffInspection = inspectSuccessfulRead(toolInput);
             try {
                 if (bootstrapRequired && toolInput.tool === "sortie_check_contract" && toolInput.sessionID !== undefined &&
                     isCoordinatorSession(toolInput.sessionID) && successfulBootstrapContractCheck(output)) {
@@ -3120,7 +3126,7 @@ export const SortieDogsPlugin = async (input, options) => {
                         }
                     }
                 }
-                await inspectSuccessfulRead(toolInput);
+                await handoffInspection;
                 let parallel = parallelCalls.get(toolInput.callID ?? "");
                 if (parallel === undefined && toolInput.tool === "task" && toolInput.sessionID !== undefined &&
                     toolInput.callID !== undefined &&
@@ -3517,14 +3523,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 completedCoordinatorParts.add(eventPart.id);
                 const text = await eventAssistantMessageText(eventSessionID, eventPart.messageID, COORDINATOR_AGENT, eventPart.id);
                 if (text !== undefined && text === eventPart.text.trim()) {
-                    completedCoordinatorMessages.add(eventPart.messageID);
                     while (completedCoordinatorParts.size > ACTIVE_SESSION_CACHE.maximum) {
                         completedCoordinatorParts.delete(completedCoordinatorParts.values().next().value);
                     }
                     while (completedCoordinatorMessages.size > ACTIVE_SESSION_CACHE.maximum) {
                         completedCoordinatorMessages.delete(completedCoordinatorMessages.values().next().value);
                     }
-                    await completeContinuationText(eventSessionID, text);
+                    await completeContinuationText(eventSessionID, text, false);
                     return;
                 }
                 completedCoordinatorParts.delete(eventPart.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.5.15",
+  "version": "0.5.17",
   "description": "Bounded, validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",