parallel-codex-tui 0.1.3 → 0.1.4

package/dist/core/config.js

@@ -1,7 +1,9 @@
-import { parse, stringify } from "@iarna/toml";
+import { parse } from "@iarna/toml";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { pathExists, readTextIfExists, writeText } from "./file-store.js";
+import { normalizeTuiThemeColorValue, normalizeTuiThemeName, TUI_THEME_FIELDS, TUI_THEME_NAMES } from "../tui/theme.js";
 const NativeSessionConfigSchema = z.object({
     enabled: z.boolean().default(true),
     resumeArgs: z.array(z.string()).default([]),
@@ -14,6 +16,26 @@ const WorkerModelConfigSchema = z.object({
     args: z.array(z.string()).default([]),
     env: z.record(z.string()).default({})
 });
+const WorkerCapabilitiesConfigSchema = z.object({
+    profile: z.enum(["codex", "claude", "generic"]),
+    writableDirArgs: z.array(z.string()).default([]),
+    freshSessionArgs: z.array(z.string()).default([])
+}).strict().superRefine((value, context) => {
+    if (value.writableDirArgs.length > 0 && !value.writableDirArgs.some((arg) => arg.includes("{dir}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["writableDirArgs"],
+            message: "writableDirArgs must include a {dir} template"
+        });
+    }
+    if (value.freshSessionArgs.length > 0 && !value.freshSessionArgs.some((arg) => arg.includes("{sessionId}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["freshSessionArgs"],
+            message: "freshSessionArgs must include a {sessionId} template"
+        });
+    }
+});
 const InteractiveCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([])
@@ -22,12 +44,45 @@ const RolePromptConfigSchema = z.object({
     title: z.string().min(1),
     instructions: z.array(z.string()).default([])
 });
+const TuiColorValueSchema = z.string().min(1).refine((value) => normalizeTuiThemeColorValue(value) !== null, {
+    message: "Invalid TUI color value. Use a Chalk color name, #rgb/#rrggbb, rgb(r,g,b), or ansi256(0..255)."
+}).transform((value) => normalizeTuiThemeColorValue(value) ?? value.trim());
+const TuiThemeNameSchema = z.preprocess((value) => typeof value === "string" ? normalizeTuiThemeName(value) ?? value.trim() : value, z.enum(TUI_THEME_NAMES)).default("codex");
+const UiColorOverridesSchema = z.object(Object.fromEntries(TUI_THEME_FIELDS.map((field) => [field, TuiColorValueSchema.optional()]))).strict().default({});
 const CodexRouterConfigSchema = z.object({
     command: z.string().min(1).default("codex"),
-    args: z.array(z.string()).default(["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"]),
-    timeoutMs: z.number().int().positive().default(120000),
-    fallback: z.enum(["simple", "complex"]).default("complex")
+    args: z.array(z.string()).default([
+        "exec",
+        "--ephemeral",
+        "--ignore-rules",
+        "-c",
+        "model_reasoning_effort=low",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "read-only",
+        "--color",
+        "never",
+        "-"
+    ]),
+    timeoutMs: z.number().int().positive().default(30000),
+    firstOutputTimeoutMs: z.number().int().positive().default(15000),
+    idleTimeoutMs: z.number().int().positive().default(15000),
+    maxOutputBytes: z.number().int().min(1024).max(16 * 1024 * 1024).default(1024 * 1024),
+    maxAttempts: z.number().int().min(1).max(3).default(2),
+    retryDelayMs: z.number().int().min(0).max(10000).default(500),
+    followUpTimeoutMs: z.number().int().positive().max(120000).default(20000),
+    fallback: z.enum(["simple", "complex"]).default("simple"),
+    env: z.record(z.string()).default({})
 });
+const OrchestrationConfigSchema = z.object({
+    maxParallelFeatures: z.number().int().min(1).max(8)
+}).strict();
+const UiConfigSchema = z.object({
+    showStatusBar: z.boolean(),
+    autoOpenFailedWorker: z.boolean(),
+    theme: TuiThemeNameSchema,
+    colors: UiColorOverridesSchema
+}).strict();
 const WorkerCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([]),
@@ -35,6 +90,7 @@ const WorkerCommandSchema = z.object({
     idleTimeoutMs: z.number().int().positive().optional(),
     firstOutputTimeoutMs: z.number().int().positive().optional(),
     model: WorkerModelConfigSchema.default({}),
+    capabilities: WorkerCapabilitiesConfigSchema,
     nativeSession: NativeSessionConfigSchema,
     interactive: InteractiveCommandSchema
 });
@@ -45,6 +101,7 @@ const AppConfigSchema = z.object({
         defaultMode: z.enum(["auto", "simple", "complex"]),
         codex: CodexRouterConfigSchema.default({})
     }),
+    orchestration: OrchestrationConfigSchema,
     workers: z.object({
         codex: WorkerCommandSchema,
         claude: WorkerCommandSchema,
@@ -62,10 +119,7 @@ const AppConfigSchema = z.object({
         actor: RolePromptConfigSchema,
         critic: RolePromptConfigSchema
     }),
-    ui: z.object({
-        showStatusBar: z.boolean(),
-        autoOpenFailedWorker: z.boolean()
-    })
+    ui: UiConfigSchema
 });
 export function defaultConfig(projectRoot) {
     return {
@@ -75,11 +129,33 @@ export function defaultConfig(projectRoot) {
             defaultMode: "auto",
             codex: {
                 command: "codex",
-                args: ["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"],
-                timeoutMs: 120000,
-                fallback: "complex"
+                args: [
+                    "exec",
+                    "--ephemeral",
+                    "--ignore-rules",
+                    "-c",
+                    "model_reasoning_effort=low",
+                    "--skip-git-repo-check",
+                    "--sandbox",
+                    "read-only",
+                    "--color",
+                    "never",
+                    "-"
+                ],
+                timeoutMs: 30000,
+                firstOutputTimeoutMs: 15000,
+                idleTimeoutMs: 15000,
+                maxOutputBytes: 1024 * 1024,
+                maxAttempts: 2,
+                retryDelayMs: 500,
+                followUpTimeoutMs: 20000,
+                fallback: "simple",
+                env: {}
             }
         },
+        orchestration: {
+            maxParallelFeatures: 3
+        },
         workers: {
             codex: {
                 command: "codex",
@@ -93,6 +169,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "codex",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["exec", "resume", "{sessionId}", "--skip-git-repo-check", "-"],
@@ -116,6 +197,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "claude",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: ["--session-id", "{sessionId}"]
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["--print", "--resume", "{sessionId}", "--permission-mode", "acceptEdits", "--output-format", "text"],
@@ -136,6 +222,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "generic",
+                    writableDirArgs: [],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["resume", "{sessionId}", "-"],
@@ -174,7 +265,9 @@ export function defaultConfig(projectRoot) {
         },
         ui: {
             showStatusBar: true,
-            autoOpenFailedWorker: true
+            autoOpenFailedWorker: true,
+            theme: "codex",
+            colors: {}
         }
     };
 }
@@ -198,9 +291,17 @@ export async function loadConfig(projectRoot) {
             ...(parsed.router ?? {}),
             codex: {
                 ...base.router.codex,
-                ...(parsed.router?.codex ?? {})
+                ...(parsed.router?.codex ?? {}),
+                env: {
+                    ...base.router.codex.env,
+                    ...(parsed.router?.codex?.env ?? {})
+                }
             }
         },
+        orchestration: {
+            ...base.orchestration,
+            ...(parsed.orchestration ?? {})
+        },
         workers: {
             codex: {
                 ...base.workers.codex,
@@ -213,6 +314,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.codex?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.codex.capabilities,
+                    ...(parsed.workers?.codex?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.codex.nativeSession,
                     ...(parsed.workers?.codex?.nativeSession ?? {})
@@ -233,6 +338,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.claude?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.claude.capabilities,
+                    ...(parsed.workers?.claude?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.claude.nativeSession,
                     ...(parsed.workers?.claude?.nativeSession ?? {})
@@ -253,6 +362,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.mock?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.mock.capabilities,
+                    ...(parsed.workers?.mock?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.mock.nativeSession,
                     ...(parsed.workers?.mock?.nativeSession ?? {})
@@ -287,29 +400,50 @@ export async function loadConfig(projectRoot) {
         },
         ui: {
             ...base.ui,
-            ...(parsed.ui ?? {})
+            ...(parsed.ui ?? {}),
+            colors: {
+                ...base.ui.colors,
+                ...(parsed.ui?.colors ?? {})
+            }
         }
     };
     return AppConfigSchema.parse(merged);
 }
+export function withUiThemeOverride(config, theme) {
+    if (!theme) {
+        return config;
+    }
+    return {
+        ...config,
+        ui: {
+            ...config.ui,
+            theme
+        }
+    };
+}
 function assertObjectSections(parsed) {
     const sections = [
         ["router", parsed.router],
         ["router.codex", parsed.router?.codex],
+        ["router.codex.env", parsed.router?.codex?.env],
+        ["orchestration", parsed.orchestration],
         ["workers", parsed.workers],
         ["workers.codex", parsed.workers?.codex],
         ["workers.codex.model", parsed.workers?.codex?.model],
         ["workers.codex.model.env", parsed.workers?.codex?.model?.env],
+        ["workers.codex.capabilities", parsed.workers?.codex?.capabilities],
         ["workers.codex.nativeSession", parsed.workers?.codex?.nativeSession],
         ["workers.codex.interactive", parsed.workers?.codex?.interactive],
         ["workers.claude", parsed.workers?.claude],
         ["workers.claude.model", parsed.workers?.claude?.model],
         ["workers.claude.model.env", parsed.workers?.claude?.model?.env],
+        ["workers.claude.capabilities", parsed.workers?.claude?.capabilities],
         ["workers.claude.nativeSession", parsed.workers?.claude?.nativeSession],
         ["workers.claude.interactive", parsed.workers?.claude?.interactive],
         ["workers.mock", parsed.workers?.mock],
         ["workers.mock.model", parsed.workers?.mock?.model],
         ["workers.mock.model.env", parsed.workers?.mock?.model?.env],
+        ["workers.mock.capabilities", parsed.workers?.mock?.capabilities],
         ["workers.mock.nativeSession", parsed.workers?.mock?.nativeSession],
         ["workers.mock.interactive", parsed.workers?.mock?.interactive],
         ["pairing", parsed.pairing],
@@ -318,7 +452,8 @@ function assertObjectSections(parsed) {
         ["roles.judge", parsed.roles?.judge],
         ["roles.actor", parsed.roles?.actor],
         ["roles.critic", parsed.roles?.critic],
-        ["ui", parsed.ui]
+        ["ui", parsed.ui],
+        ["ui.colors", parsed.ui?.colors]
     ];
     for (const [path, value] of sections) {
         if (value !== undefined && !isPlainObject(value)) {
@@ -330,13 +465,8 @@ function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 export async function writeDefaultConfig(projectRoot) {
-    const config = defaultConfig(projectRoot);
-    const tomlText = stringify({
-        router: config.router,
-        workers: config.workers,
-        pairing: config.pairing,
-        roles: config.roles,
-        ui: config.ui
-    });
-    await writeText(configPath(projectRoot), tomlText);
+    await writeText(configPath(projectRoot), await readExampleConfig());
+}
+async function readExampleConfig() {
+    return readFile(new URL("../../.parallel-codex/config.example.toml", import.meta.url), "utf8");
 }

package/dist/core/file-store.js

@@ -1,5 +1,8 @@
-import { mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+const appendQueues = new Map();
+const defaultRecentJsonLineChunkBytes = 64 * 1024;
+const defaultRecentJsonLineMaxBytes = 2 * 1024 * 1024;
 export async function ensureDir(path) {
     await mkdir(path, { recursive: true });
 }
@@ -38,16 +41,120 @@ export async function readJson(path, schema) {
     return schema.parse(JSON.parse(text));
 }
 export async function appendJsonLine(path, value) {
-    await ensureDir(dirname(path));
-    await writeFile(path, `${JSON.stringify(value)}\n`, { encoding: "utf8", flag: "a" });
+    await appendFile(path, `${JSON.stringify(value)}\n`);
 }
 export async function writeText(path, value) {
     await ensureDir(dirname(path));
     await writeFile(path, value, "utf8");
 }
 export async function appendText(path, value) {
-    await ensureDir(dirname(path));
-    await writeFile(path, value, { encoding: "utf8", flag: "a" });
+    await appendFile(path, value);
+}
+export async function readRecentJsonLines(path, schema, limit, options = {}) {
+    const targetLimit = Number.isFinite(limit)
+        ? Math.min(10000, Math.max(0, Math.trunc(limit)))
+        : 10000;
+    if (targetLimit === 0) {
+        return [];
+    }
+    const chunkBytes = boundedPositiveInteger(options.chunkBytes, defaultRecentJsonLineChunkBytes, 4 * 1024 * 1024);
+    const maxLineBytes = boundedPositiveInteger(options.maxLineBytes, defaultRecentJsonLineMaxBytes, 16 * 1024 * 1024);
+    let handle;
+    try {
+        handle = await open(path, "r");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    try {
+        let position = (await handle.stat()).size;
+        let lineSegments = [];
+        let lineBytes = 0;
+        let lineTooLong = false;
+        const newestFirst = [];
+        const addLineSegment = (segment) => {
+            if (segment.length === 0 || lineTooLong) {
+                return;
+            }
+            lineBytes += segment.length;
+            if (lineBytes > maxLineBytes) {
+                lineSegments = [];
+                lineTooLong = true;
+                return;
+            }
+            lineSegments.push(Buffer.from(segment));
+        };
+        const finishLine = () => {
+            if (!lineTooLong && lineBytes > 0) {
+                const line = Buffer.concat([...lineSegments].reverse(), lineBytes).toString("utf8").trim();
+                if (line) {
+                    try {
+                        const parsed = schema.safeParse(JSON.parse(line));
+                        if (parsed.success) {
+                            newestFirst.push(parsed.data);
+                        }
+                    }
+                    catch {
+                        // Invalid or partial rows do not hide earlier valid records.
+                    }
+                }
+            }
+            lineSegments = [];
+            lineBytes = 0;
+            lineTooLong = false;
+        };
+        while (position > 0 && newestFirst.length < targetLimit) {
+            const requested = Math.min(chunkBytes, position);
+            position -= requested;
+            const buffer = Buffer.allocUnsafe(requested);
+            const { bytesRead } = await handle.read(buffer, 0, requested, position);
+            if (bytesRead === 0) {
+                continue;
+            }
+            let segmentEnd = bytesRead;
+            for (let index = bytesRead - 1; index >= 0; index -= 1) {
+                if (buffer[index] !== 0x0a) {
+                    continue;
+                }
+                addLineSegment(buffer.subarray(index + 1, segmentEnd));
+                finishLine();
+                segmentEnd = index;
+                if (newestFirst.length >= targetLimit) {
+                    break;
+                }
+            }
+            if (newestFirst.length < targetLimit) {
+                addLineSegment(buffer.subarray(0, segmentEnd));
+            }
+        }
+        if (position === 0 && newestFirst.length < targetLimit && (lineBytes > 0 || lineTooLong)) {
+            finishLine();
+        }
+        return newestFirst.reverse();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function appendFile(path, value) {
+    const key = resolve(path);
+    const previous = appendQueues.get(key) ?? Promise.resolve();
+    const operation = previous.catch(() => undefined).then(async () => {
+        await ensureDir(dirname(path));
+        await writeFile(path, value, { encoding: "utf8", flag: "a" });
+    });
+    appendQueues.set(key, operation);
+    try {
+        await operation;
+    }
+    finally {
+        if (appendQueues.get(key) === operation) {
+            appendQueues.delete(key);
+        }
+    }
 }
 export async function readTextIfExists(path) {
     if (!(await pathExists(path))) {
@@ -65,3 +172,9 @@ export async function removeIfExists(path) {
         }
     }
 }
+function boundedPositiveInteger(value, fallback, maximum) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(maximum, Math.max(1, Math.trunc(value)));
+}

package/dist/core/lease-finalization.js

@@ -0,0 +1,22 @@
+export async function runWithLeaseFinalization(subject, lease, run) {
+    const outcome = await run().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    try {
+        await lease.release();
+    }
+    catch (releaseError) {
+        const releaseSummary = `${subject} lease release failed: ${errorMessage(releaseError)}`;
+        if (!outcome.ok) {
+            throw new Error(`${errorMessage(outcome.error)}; ${releaseSummary}`, {
+                cause: new AggregateError([outcome.error, releaseError])
+            });
+        }
+        throw new Error(releaseSummary, { cause: releaseError });
+    }
+    if (!outcome.ok) {
+        throw outcome.error;
+    }
+    return outcome.value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/paths.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { TaskSessionIdSchema } from "../domain/schemas.js";
 function pad(value) {
     return String(value).padStart(2, "0");
 }
@@ -16,5 +17,11 @@ export function routerRuntimeDir(appRoot, dataDir) {
     return join(appRoot, dataDir, "router");
 }
 export function taskDir(projectRoot, dataDir, taskId) {
+    if (!taskSessionIdIsValid(taskId)) {
+        throw new Error(`Invalid task session id: ${JSON.stringify(taskId)}`);
+    }
     return join(sessionsRoot(projectRoot, dataDir), taskId);
 }
+export function taskSessionIdIsValid(taskId) {
+    return TaskSessionIdSchema.safeParse(taskId).success;
+}

package/dist/core/process-identity.js

@@ -0,0 +1,48 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export async function readProcessStartToken(pid) {
+    if (!processIsAlive(pid)) {
+        return null;
+    }
+    if (process.platform === "linux") {
+        try {
+            const stat = await readFile(`/proc/${pid}/stat`, "utf8");
+            const fields = stat.slice(stat.lastIndexOf(") ") + 2).trim().split(/\s+/);
+            const startTick = fields[19];
+            if (startTick) {
+                return `linux:${startTick}`;
+            }
+        }
+        catch {
+            // Fall through to ps when procfs is unavailable.
+        }
+    }
+    if (process.platform !== "win32") {
+        try {
+            const result = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], {
+                encoding: "utf8",
+                timeout: 1000
+            });
+            const value = String(result.stdout).trim().replace(/\s+/g, " ");
+            return value ? `ps:${value}` : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/core/process-mutation-turn.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { ensureDir, readJson, removeIfExists, writeJson } from "./file-store.js";
+import { processIsAlive, readProcessStartToken } from "./process-identity.js";
+const ProcessMutationIntentSchema = z.object({
+    version: z.literal(1),
+    intent_id: z.string().min(1),
+    pid: z.number().int().positive(),
+    created_at: z.string().datetime(),
+    choosing: z.boolean(),
+    ticket: z.number().int().nonnegative(),
+    process_start_token: z.string().min(1).optional()
+});
+let currentProcessStartToken = null;
+export async function acquireProcessMutationTurn(directory, options) {
+    validateIntentPrefix(options.intentPrefix);
+    await ensureDir(directory);
+    const identity = await currentMutationIdentity();
+    const intentId = randomUUID();
+    const path = join(directory, `${options.intentPrefix}${intentId}.json`);
+    let intent = ProcessMutationIntentSchema.parse({
+        version: 1,
+        intent_id: intentId,
+        pid: identity.pid,
+        created_at: new Date().toISOString(),
+        choosing: true,
+        ticket: 0,
+        ...(identity.process_start_token ? { process_start_token: identity.process_start_token } : {})
+    });
+    await writeJson(path, intent);
+    try {
+        const existing = await readActiveIntents(directory, options.intentPrefix);
+        intent = {
+            ...intent,
+            choosing: false,
+            ticket: Math.max(0, ...existing.map((candidate) => candidate.ticket)) + 1
+        };
+        await writeJson(path, intent);
+        const deadline = Date.now() + (options.timeoutMs ?? 5000);
+        while (true) {
+            const candidates = await readActiveIntents(directory, options.intentPrefix);
+            const blocked = candidates.some((candidate) => (candidate.intent_id !== intent.intent_id
+                && (candidate.choosing || intentPrecedes(candidate, intent))));
+            if (!blocked) {
+                let released = false;
+                return {
+                    release: async () => {
+                        if (released) {
+                            return;
+                        }
+                        released = true;
+                        await removeIfExists(path);
+                    }
+                };
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(options.timeoutMessage);
+            }
+            await delay(options.pollMs ?? 5);
+        }
+    }
+    catch (error) {
+        await removeIfExists(path);
+        throw error;
+    }
+}
+async function currentMutationIdentity() {
+    currentProcessStartToken ??= readProcessStartToken(process.pid);
+    const processStartToken = await currentProcessStartToken;
+    return {
+        pid: process.pid,
+        ...(processStartToken ? { process_start_token: processStartToken } : {})
+    };
+}
+async function readActiveIntents(directory, prefix) {
+    const names = await readdir(directory);
+    const tokenReads = new Map();
+    const active = [];
+    for (const name of names) {
+        if (!name.startsWith(prefix) || !name.endsWith(".json")) {
+            continue;
+        }
+        const path = join(directory, name);
+        const intent = await readValidIntent(path);
+        if (!intent || !processIsAlive(intent.pid)) {
+            await removeIfExists(path);
+            continue;
+        }
+        if (intent.process_start_token) {
+            let tokenRead = tokenReads.get(intent.pid);
+            if (!tokenRead) {
+                tokenRead = readProcessStartToken(intent.pid);
+                tokenReads.set(intent.pid, tokenRead);
+            }
+            const currentToken = await tokenRead;
+            if (!currentToken || currentToken !== intent.process_start_token) {
+                await removeIfExists(path);
+                continue;
+            }
+        }
+        active.push(intent);
+    }
+    return active;
+}
+async function readValidIntent(path) {
+    try {
+        return await readJson(path, ProcessMutationIntentSchema);
+    }
+    catch {
+        return null;
+    }
+}
+function intentPrecedes(candidate, current) {
+    if (candidate.ticket !== current.ticket) {
+        return candidate.ticket < current.ticket;
+    }
+    return candidate.intent_id < current.intent_id;
+}
+function validateIntentPrefix(prefix) {
+    if (!prefix.startsWith(".") || prefix.includes("/") || prefix.includes("\\")) {
+        throw new Error(`Invalid process mutation intent prefix: ${prefix}`);
+    }
+}
+async function delay(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}