doer-agent 0.4.6 → 0.4.8

package/README.md

@@ -142,6 +142,6 @@ curl -X POST 'http://localhost:2020/api/users/<userId>/agent/secret' \
 
 ## 참고
 
-- `runtime/`에는 실행 보조 스크립트가 들어 있습니다.
+- `runtime/`에는 Git 인증 등 실행 보조 스크립트가 들어 있습니다.
 - Playwright MCP 프록시는 에이전트 상태 디렉터리(`~/.doer-agent`) 아래 소켓을 사용합니다.
 - 이 저장소에는 예전 README에 있던 `scripts/build.sh`, `scripts/publish.sh`, `docker-compose.dev.yml`이 없습니다. 현재 문서는 실제 파일 구조 기준으로 정리되어 있습니다.

package/dist/agent-codex-cli.js

@@ -1,4 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 function shellSingleQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
@@ -6,6 +8,9 @@ function shellSingleQuote(value) {
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
+function toTomlStringArray(values) {
+    return `[${values.map((value) => toTomlStringLiteral(value)).join(", ")}]`;
+}
 function hasDirectCodexBinary() {
     const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
         stdio: "ignore",
@@ -27,6 +32,7 @@ export function buildManagedCodexArgs(args) {
         ...(args.modelInstructionsFile
             ? ["--config", `model_instructions_file=${toTomlStringLiteral(args.modelInstructionsFile)}`]
             : []),
+        ...(args.configOverrides ?? []),
     ];
     const imageArgs = args.imagePaths.flatMap((imagePath) => ["--image", imagePath]);
     return [
@@ -39,6 +45,26 @@ export function buildManagedCodexArgs(args) {
             : ["exec", ...imageArgs, ...promptArgs]),
     ];
 }
+export function buildDaemonMcpConfigArgs(args) {
+    const serverName = args.serverName?.trim() || "doer_daemon";
+    const distEntry = path.join(args.agentProjectDir, "dist", "daemon-mcp-server.js");
+    const srcEntry = path.join(args.agentProjectDir, "src", "daemon-mcp-server.ts");
+    const tsxLoaderPath = path.join(args.agentProjectDir, "node_modules", "tsx", "dist", "loader.mjs");
+    const command = process.execPath;
+    const commandArgs = existsSync(distEntry)
+        ? [distEntry, "--workspace-root", args.workspaceRoot]
+        : ["--import", tsxLoaderPath, srcEntry, "--workspace-root", args.workspaceRoot];
+    return [
+        "--config",
+        `mcp_servers.${serverName}.command=${toTomlStringLiteral(command)}`,
+        "--config",
+        `mcp_servers.${serverName}.args=${toTomlStringArray(commandArgs)}`,
+        "--config",
+        `mcp_servers.${serverName}.env.DOER_DAEMON_WORKSPACE_ROOT=${toTomlStringLiteral(args.workspaceRoot)}`,
+        "--config",
+        `mcp_servers.${serverName}.enabled=true`,
+    ];
+}
 export function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");
     const direct = `exec codex ${quotedArgs}`;

package/dist/agent-daemon-rpc.js

@@ -0,0 +1,475 @@
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { StringCodec } from "nats";
+import { buildAgentSettingsEnvPatch } from "./agent-settings.js";
+import { normalizeEnvPatch, sleep } from "./agent-runtime-utils.js";
+import { sendSignalToPid } from "./agent-task-execution.js";
+const daemonRpcCodec = StringCodec();
+const DAEMON_ID_PATTERN = /^[A-Za-z0-9_-]{6,32}$/;
+function getDaemonsRoot(workspaceRoot) {
+    return path.join(workspaceRoot, ".doer-agent", "daemons");
+}
+function getDaemonDir(workspaceRoot, daemonId) {
+    return path.join(getDaemonsRoot(workspaceRoot), daemonId);
+}
+function getDaemonStatePath(workspaceRoot, daemonId) {
+    return path.join(getDaemonDir(workspaceRoot, daemonId), "state.json");
+}
+function getDaemonEventsPath(workspaceRoot, daemonId) {
+    return path.join(getDaemonDir(workspaceRoot, daemonId), "events.jsonl");
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createDaemonId() {
+    return crypto.randomBytes(9).toString("base64url").slice(0, 12);
+}
+function normalizeAction(value) {
+    if (value === "list" || value === "inspect" || value === "start" || value === "stop" || value === "restart" || value === "delete" || value === "logs") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function normalizeDaemonId(value) {
+    const daemonId = typeof value === "string" ? value.trim() : "";
+    if (!DAEMON_ID_PATTERN.test(daemonId)) {
+        throw new Error("invalid daemonId");
+    }
+    return daemonId;
+}
+function normalizeCommand(value) {
+    const command = typeof value === "string" ? value.trim() : "";
+    if (!command) {
+        throw new Error("command is required");
+    }
+    return command;
+}
+function normalizeLabel(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const label = value.trim();
+    return label ? label.slice(0, 120) : null;
+}
+function normalizeLimit(value, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(Math.floor(numeric), 1000));
+}
+function normalizeStateRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const id = typeof row.id === "string" ? row.id.trim() : "";
+    const command = typeof row.command === "string" ? row.command.trim() : "";
+    const cwd = typeof row.cwd === "string" ? row.cwd.trim() : "";
+    const startedAt = typeof row.startedAt === "string" ? row.startedAt.trim() : "";
+    const label = typeof row.label === "string" && row.label.trim() ? row.label.trim() : null;
+    const stoppedAt = typeof row.stoppedAt === "string" && row.stoppedAt.trim() ? row.stoppedAt.trim() : null;
+    const pid = typeof row.pid === "number" && Number.isInteger(row.pid) && row.pid > 0 ? row.pid : null;
+    const runnerPid = typeof row.runnerPid === "number" && Number.isInteger(row.runnerPid) && row.runnerPid > 0 ? row.runnerPid : null;
+    const lastExitCode = typeof row.lastExitCode === "number" && Number.isInteger(row.lastExitCode) ? row.lastExitCode : null;
+    if (!DAEMON_ID_PATTERN.test(id) || !command || !cwd || !startedAt) {
+        return null;
+    }
+    return {
+        id,
+        label,
+        command,
+        cwd,
+        pid,
+        runnerPid,
+        startedAt,
+        stoppedAt,
+        lastExitCode,
+    };
+}
+function normalizeLogEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const ts = typeof row.ts === "string" ? row.ts.trim() : "";
+    const type = row.type === "start" || row.type === "stdout" || row.type === "stderr" || row.type === "exit" || row.type === "signal" || row.type === "error"
+        ? row.type
+        : null;
+    if (!ts || !type) {
+        return null;
+    }
+    return {
+        ts,
+        type,
+        text: typeof row.text === "string" ? row.text : null,
+        pid: typeof row.pid === "number" && Number.isInteger(row.pid) && row.pid > 0 ? row.pid : null,
+        code: typeof row.code === "number" && Number.isInteger(row.code) ? row.code : null,
+        signal: typeof row.signal === "string" && row.signal.trim() ? row.signal.trim() : null,
+    };
+}
+async function readDaemonState(workspaceRoot, daemonId) {
+    const raw = await readFile(getDaemonStatePath(workspaceRoot, daemonId), "utf8").catch(() => null);
+    if (!raw) {
+        return null;
+    }
+    const parsed = JSON.parse(raw);
+    return normalizeStateRecord(parsed);
+}
+async function writeDaemonState(workspaceRoot, state) {
+    await mkdir(getDaemonDir(workspaceRoot, state.id), { recursive: true });
+    await writeFile(getDaemonStatePath(workspaceRoot, state.id), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function toDaemonSnapshot(state) {
+    const runnerAlive = isPidAlive(state.runnerPid);
+    const processAlive = isPidAlive(state.pid);
+    const status = runnerAlive || processAlive ? "running" : state.lastExitCode !== null && state.lastExitCode !== 0 ? "failed" : "stopped";
+    return {
+        ...state,
+        status,
+        displayName: state.label ?? state.command,
+    };
+}
+async function readJsonlTail(filePath, limit) {
+    const raw = await readFile(filePath, "utf8").catch(() => "");
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-limit)
+        .map((line) => {
+        try {
+            return normalizeLogEvent(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((event) => Boolean(event));
+}
+function resolveDaemonRunnerEntry(agentProjectDir) {
+    const distEntry = path.join(agentProjectDir, "dist", "daemon-log-runner.js");
+    const srcEntry = path.join(agentProjectDir, "src", "daemon-log-runner.ts");
+    const tsxLoaderPath = path.join(agentProjectDir, "node_modules", "tsx", "dist", "loader.mjs");
+    if (existsSync(distEntry)) {
+        return {
+            command: process.execPath,
+            args: [distEntry],
+        };
+    }
+    return {
+        command: process.execPath,
+        args: ["--import", tsxLoaderPath, srcEntry],
+    };
+}
+export async function listAgentDaemonsLocal(workspaceRoot) {
+    const root = getDaemonsRoot(workspaceRoot);
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const states = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && DAEMON_ID_PATTERN.test(entry.name))
+        .map(async (entry) => readDaemonState(workspaceRoot, entry.name)));
+    return states
+        .filter((state) => Boolean(state))
+        .map((state) => toDaemonSnapshot(state))
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export async function getAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    return toDaemonSnapshot(state);
+}
+export async function stopAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    const targetPid = isPidAlive(state.runnerPid) ? state.runnerPid : state.pid;
+    if (!targetPid) {
+        const stopped = {
+            ...state,
+            pid: null,
+            runnerPid: null,
+            stoppedAt: state.stoppedAt ?? new Date().toISOString(),
+        };
+        await writeDaemonState(workspaceRoot, stopped);
+        return toDaemonSnapshot(stopped);
+    }
+    try {
+        sendSignalToPid(targetPid, "SIGTERM");
+    }
+    catch {
+        // Ignore and fall through to polling.
+    }
+    for (let index = 0; index < 30; index += 1) {
+        await sleep(100);
+        const latest = await readDaemonState(workspaceRoot, daemonId);
+        if (!latest || (!isPidAlive(latest.runnerPid) && !isPidAlive(latest.pid))) {
+            return latest ? toDaemonSnapshot(latest) : toDaemonSnapshot({
+                ...state,
+                pid: null,
+                runnerPid: null,
+                stoppedAt: new Date().toISOString(),
+            });
+        }
+    }
+    try {
+        sendSignalToPid(targetPid, "SIGKILL");
+    }
+    catch {
+        // noop
+    }
+    for (let index = 0; index < 15; index += 1) {
+        await sleep(100);
+        const latest = await readDaemonState(workspaceRoot, daemonId);
+        if (!latest || (!isPidAlive(latest.runnerPid) && !isPidAlive(latest.pid))) {
+            return latest ? toDaemonSnapshot(latest) : toDaemonSnapshot({
+                ...state,
+                pid: null,
+                runnerPid: null,
+                stoppedAt: new Date().toISOString(),
+            });
+        }
+    }
+    throw new Error("failed to stop daemon");
+}
+async function spawnDaemonLocal(args) {
+    const daemonId = args.daemonId ?? createDaemonId();
+    const daemonDir = getDaemonDir(args.workspaceRoot, daemonId);
+    const statePath = getDaemonStatePath(args.workspaceRoot, daemonId);
+    const eventsPath = getDaemonEventsPath(args.workspaceRoot, daemonId);
+    await mkdir(daemonDir, { recursive: true });
+    await mkdir(path.join(args.workspaceRoot, ".codex"), { recursive: true });
+    const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
+    const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
+    const baseState = {
+        id: daemonId,
+        label: args.label,
+        command: args.command,
+        cwd: args.cwd,
+        pid: null,
+        runnerPid: null,
+        startedAt: new Date().toISOString(),
+        stoppedAt: null,
+        lastExitCode: null,
+    };
+    await writeDaemonState(args.workspaceRoot, baseState);
+    const env = {
+        ...process.env,
+        ...buildAgentSettingsEnvPatch(settings),
+        ...args.envPatch,
+        WORKSPACE: args.cwd,
+        CODEX_HOME: path.join(args.workspaceRoot, ".codex"),
+        PATH: [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter),
+        DOER_DAEMON_ID: daemonId,
+        DOER_DAEMON_COMMAND: args.command,
+        DOER_DAEMON_CWD: args.cwd,
+        DOER_DAEMON_STATE_PATH: statePath,
+        DOER_DAEMON_EVENTS_PATH: eventsPath,
+        DOER_DAEMON_SHELL_PATH: args.resolveShellPath(),
+    };
+    const runner = resolveDaemonRunnerEntry(args.agentProjectDir);
+    const child = spawn(runner.command, runner.args, {
+        cwd: args.cwd,
+        env,
+        detached: process.platform !== "win32",
+        stdio: "ignore",
+    });
+    if (typeof child.pid !== "number" || child.pid <= 0) {
+        throw new Error("failed to start daemon process");
+    }
+    child.unref();
+    await writeDaemonState(args.workspaceRoot, {
+        ...baseState,
+        runnerPid: child.pid,
+    });
+    for (let index = 0; index < 20; index += 1) {
+        await sleep(50);
+        const latest = await readDaemonState(args.workspaceRoot, daemonId);
+        if (latest && (latest.pid || latest.lastExitCode !== null)) {
+            return toDaemonSnapshot(latest);
+        }
+    }
+    const latest = await readDaemonState(args.workspaceRoot, daemonId);
+    return toDaemonSnapshot(latest ?? { ...baseState, runnerPid: child.pid });
+}
+export async function startAgentDaemonLocal(args) {
+    return await spawnDaemonLocal({
+        workspaceRoot: args.workspaceRoot,
+        agentProjectDir: args.agentProjectDir,
+        command: normalizeCommand(args.request.command),
+        cwd: args.resolveTaskWorkspace(typeof args.request.cwd === "string" ? args.request.cwd : null),
+        label: normalizeLabel(args.request.label),
+        envPatch: normalizeEnvPatch(args.request.envPatch),
+        resolveShellPath: args.resolveShellPath,
+        readAgentSettingsConfig: args.readAgentSettingsConfig,
+    });
+}
+export async function restartAgentDaemonLocal(args) {
+    const state = await readDaemonState(args.workspaceRoot, args.daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    if (isPidAlive(state.runnerPid) || isPidAlive(state.pid)) {
+        await stopAgentDaemonLocal(args.workspaceRoot, args.daemonId);
+    }
+    return await spawnDaemonLocal({
+        workspaceRoot: args.workspaceRoot,
+        agentProjectDir: args.agentProjectDir,
+        daemonId: state.id,
+        command: state.command,
+        cwd: state.cwd,
+        label: state.label,
+        envPatch: {},
+        resolveShellPath: args.resolveShellPath,
+        readAgentSettingsConfig: args.readAgentSettingsConfig,
+    });
+}
+export async function deleteAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        return;
+    }
+    if (isPidAlive(state.runnerPid) || isPidAlive(state.pid)) {
+        await stopAgentDaemonLocal(workspaceRoot, daemonId);
+    }
+    await rm(getDaemonDir(workspaceRoot, daemonId), { recursive: true, force: true });
+}
+export async function readAgentDaemonLogsLocal(args) {
+    const state = await readDaemonState(args.workspaceRoot, args.daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    const limit = normalizeLimit(args.limit, 100);
+    return {
+        daemon: toDaemonSnapshot(state),
+        events: await readJsonlTail(getDaemonEventsPath(args.workspaceRoot, args.daemonId), limit),
+    };
+}
+async function executeDaemonRpc(args) {
+    const action = normalizeAction(args.request.action);
+    if (action === "list") {
+        return {
+            ok: true,
+            action,
+            daemons: await listAgentDaemonsLocal(args.workspaceRoot),
+        };
+    }
+    if (action === "inspect") {
+        const daemonId = normalizeDaemonId(args.request.daemonId);
+        return {
+            ok: true,
+            action,
+            daemon: await getAgentDaemonLocal(args.workspaceRoot, daemonId),
+        };
+    }
+    if (action === "start") {
+        return {
+            ok: true,
+            action,
+            daemon: await startAgentDaemonLocal({
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                request: args.request,
+                resolveShellPath: args.resolveShellPath,
+                resolveTaskWorkspace: args.resolveTaskWorkspace,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+            }),
+        };
+    }
+    const daemonId = normalizeDaemonId(args.request.daemonId);
+    if (action === "stop") {
+        return {
+            ok: true,
+            action,
+            daemon: await stopAgentDaemonLocal(args.workspaceRoot, daemonId),
+        };
+    }
+    if (action === "restart") {
+        return {
+            ok: true,
+            action,
+            daemon: await restartAgentDaemonLocal({
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                daemonId,
+                resolveShellPath: args.resolveShellPath,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+            }),
+        };
+    }
+    if (action === "delete") {
+        await deleteAgentDaemonLocal(args.workspaceRoot, daemonId);
+        return {
+            ok: true,
+            action,
+            daemonId,
+        };
+    }
+    const limit = normalizeLimit(args.request.limit, 100);
+    return {
+        ok: true,
+        action,
+        ...(await readAgentDaemonLogsLocal({ workspaceRoot: args.workspaceRoot, daemonId, limit })),
+        limit,
+    };
+}
+export async function handleDaemonRpcMessage(args) {
+    let requestId = "unknown";
+    try {
+        const request = JSON.parse(daemonRpcCodec.decode(args.msg.data));
+        requestId = typeof request.requestId === "string" ? request.requestId : "unknown";
+        const payload = await executeDaemonRpc({
+            workspaceRoot: args.workspaceRoot,
+            agentProjectDir: args.agentProjectDir,
+            request,
+            resolveShellPath: args.resolveShellPath,
+            resolveTaskWorkspace: args.resolveTaskWorkspace,
+            readAgentSettingsConfig: args.readAgentSettingsConfig,
+        });
+        args.msg.respond(daemonRpcCodec.encode(JSON.stringify({ requestId, ...payload })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError?.(`daemon rpc failed requestId=${requestId} error=${message}`);
+        args.msg.respond(daemonRpcCodec.encode(JSON.stringify({ requestId, ok: false, error: message })));
+    }
+}
+export function subscribeToDaemonRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`daemon rpc subscription error: ${message}`);
+                return;
+            }
+            void handleDaemonRpcMessage({
+                msg,
+                nc: args.nc,
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                resolveShellPath: args.resolveShellPath,
+                resolveTaskWorkspace: args.resolveTaskWorkspace,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`daemon rpc subscribed subject=${args.subject}`);
+}

package/dist/agent-fs-rpc.js

@@ -3,6 +3,7 @@ import { mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "nod
 import crypto from "node:crypto";
 import { StringCodec } from "nats";
 import { create as createTar, extract as extractTar } from "tar";
+import { validateImageBytes } from "./agent-runtime-utils.js";
 const fsRpcCodec = StringCodec();
 function normalizeFsRpcPath(workspaceRoot, rawPath) {
     const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
@@ -295,6 +296,10 @@ async function executeFsRpc(args) {
             throw new Error(text || `download failed: ${response.status}`);
         }
         const bytes = Buffer.from(await response.arrayBuffer());
+        const validationError = validateImageBytes(abs, bytes);
+        if (validationError) {
+            throw new Error(validationError);
+        }
         const parentDir = path.dirname(abs);
         await mkdir(parentDir, { recursive: true });
         await writeFile(abs, bytes);

package/dist/agent-run-state.js

@@ -72,10 +72,68 @@ function buildImmediateRunEvent(task, type) {
         finishedAt: task.finishedAt,
     };
 }
-export async function resetRunsDir(workspaceRoot) {
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error?.code;
+        return code === "EPERM";
+    }
+}
+async function removePathIfStale(pathToRemove, pid) {
+    if (isPidAlive(pid)) {
+        return;
+    }
+    await rm(pathToRemove, { recursive: true, force: true }).catch(() => undefined);
+}
+export async function pruneStaleRunsDir(workspaceRoot) {
     const dir = await resolveRunsDir(workspaceRoot);
-    await rm(dir, { recursive: true, force: true }).catch(() => undefined);
-    await mkdir(dir, { recursive: true });
+    const names = await readdir(dir).catch(() => []);
+    for (const name of names) {
+        const entryPath = path.join(dir, name);
+        if (name === "locks") {
+            const lockNames = await readdir(entryPath).catch(() => []);
+            for (const lockName of lockNames) {
+                const lockPath = path.join(entryPath, lockName);
+                const contents = await readFile(lockPath, "utf8").catch(() => null);
+                if (!contents) {
+                    await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+                    continue;
+                }
+                let pid = null;
+                try {
+                    const parsed = JSON.parse(contents);
+                    pid = typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 ? parsed.pid : null;
+                }
+                catch {
+                    pid = null;
+                }
+                await removePathIfStale(lockPath, pid);
+            }
+            continue;
+        }
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        const contents = await readFile(entryPath, "utf8").catch(() => null);
+        if (!contents) {
+            await rm(entryPath, { recursive: true, force: true }).catch(() => undefined);
+            continue;
+        }
+        let task = null;
+        try {
+            task = normalizePersistedRunTask(JSON.parse(contents));
+        }
+        catch {
+            task = null;
+        }
+        await removePathIfStale(entryPath, task?.processPid ?? null);
+    }
 }
 export async function persistRunTask(workspaceRoot, task) {
     const dir = await resolveRunsDir(workspaceRoot);