parallel-codex-tui 0.1.3 → 0.1.5

package/dist/core/task-session-details.js

@@ -0,0 +1,175 @@
+import { readdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { NativeSessionSchema, RetiredNativeSessionSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
+import { pathExists, readJson, readTextIfExists } from "./file-store.js";
+export async function loadTaskSessionDetails(input) {
+    const [turns, workers] = await Promise.all([
+        readTaskTurns(input.taskDir),
+        readTaskWorkers(input.taskDir, input.modelNames ?? {})
+    ]);
+    const turnById = new Map(turns.map((turn) => [turn.turnId, turn]));
+    for (const worker of workers) {
+        let turn = turnById.get(worker.turnId);
+        if (!turn) {
+            turn = {
+                turnId: worker.turnId,
+                createdAt: worker.lastActivityAt,
+                request: "",
+                workers: []
+            };
+            turnById.set(worker.turnId, turn);
+            turns.push(turn);
+        }
+        turn.workers.push(worker);
+    }
+    turns.sort((left, right) => left.turnId.localeCompare(right.turnId));
+    for (const turn of turns) {
+        turn.workers.sort(compareTaskSessionWorkers);
+    }
+    return {
+        task: input.task,
+        projectName: basename(input.task.cwd) || input.task.cwd,
+        projectPath: input.task.cwd,
+        turns,
+        workers
+    };
+}
+async function readTaskTurns(taskDir) {
+    const turnsDir = join(taskDir, "turns");
+    let entries;
+    try {
+        entries = await readdir(turnsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const turns = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && /^\d{4}$/.test(entry.name))
+        .map(async (entry) => {
+        const dir = join(turnsDir, entry.name);
+        try {
+            const meta = await readJson(join(dir, "turn.json"), TurnMetaSchema);
+            if (meta.turn_id !== entry.name) {
+                return null;
+            }
+            return {
+                turnId: meta.turn_id,
+                createdAt: meta.created_at,
+                request: compactTaskRequest(await readTextIfExists(join(dir, "user.md"))),
+                workers: []
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return turns
+        .filter((turn) => turn !== null)
+        .sort((left, right) => left.turnId.localeCompare(right.turnId));
+}
+async function readTaskWorkers(taskDir, modelNames) {
+    let entries;
+    try {
+        entries = await readdir(taskDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const workers = await Promise.all(entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+        const dir = join(taskDir, entry.name);
+        const statusPath = join(dir, "status.json");
+        if (!(await pathExists(statusPath))) {
+            return null;
+        }
+        try {
+            const status = await readJson(statusPath, WorkerStatusSchema);
+            const nativeSession = await readActiveNativeSession(dir, status.worker_id);
+            return {
+                id: status.worker_id,
+                turnId: taskSessionWorkerTurnId(status.worker_id, status.feature_id),
+                ...(status.feature_id ? { featureId: status.feature_id } : {}),
+                ...(status.feature_title ? { featureTitle: status.feature_title } : {}),
+                role: status.role,
+                engine: status.engine,
+                model: status.model_name?.trim() || modelNames[status.engine]?.trim() || "",
+                ...(status.model_provider?.trim() ? { modelProvider: status.model_provider.trim() } : {}),
+                state: status.state,
+                phase: status.phase,
+                summary: status.summary,
+                lastActivityAt: laterTimestamp(status.last_event_at, nativeSession?.lastUsedAt),
+                dir,
+                statusPath,
+                outputLogPath: join(dir, "output.log"),
+                nativeSession
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return workers
+        .filter((worker) => worker !== null)
+        .sort((left, right) => (left.turnId.localeCompare(right.turnId)
+        || compareTaskSessionWorkers(left, right)));
+}
+async function readActiveNativeSession(workerDir, workerId) {
+    const activePath = join(workerDir, "native-session.json");
+    if (!(await pathExists(activePath))) {
+        return null;
+    }
+    try {
+        const active = await readJson(activePath, NativeSessionSchema);
+        if (active.worker_id !== workerId) {
+            return null;
+        }
+        const retiredPath = join(workerDir, "native-session.retired.json");
+        if (await pathExists(retiredPath)) {
+            try {
+                const retired = await readJson(retiredPath, RetiredNativeSessionSchema);
+                if (retired.session_id === active.session_id) {
+                    return null;
+                }
+            }
+            catch {
+                // A malformed retirement record cannot hide a valid active session.
+            }
+        }
+        return {
+            sessionId: active.session_id,
+            cwd: active.cwd,
+            writableDirs: active.writable_dirs ?? [],
+            createdAt: active.created_at,
+            lastUsedAt: active.last_used_at,
+            source: active.source
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function taskSessionWorkerTurnId(workerId, featureId) {
+    const featureTurn = featureId?.match(/^(\d{4})(?:-|$)/)?.[1];
+    const waveTurn = workerId.match(/-wave-(\d{4})-/)?.[1];
+    const finalTurn = workerId.match(/-final-(\d{4})$/)?.[1];
+    const taskTurn = workerId.match(/-(\d{4})$/)?.[1];
+    return featureTurn ?? waveTurn ?? finalTurn ?? taskTurn ?? "0001";
+}
+function compareTaskSessionWorkers(left, right) {
+    return taskSessionWorkerStage(left) - taskSessionWorkerStage(right)
+        || left.id.localeCompare(right.id);
+}
+function taskSessionWorkerStage(worker) {
+    if (worker.role === "judge" && /-final-\d{4}$/.test(worker.id)) {
+        return 4;
+    }
+    return ["main", "judge", "actor", "critic"].indexOf(worker.role);
+}
+function compactTaskRequest(request) {
+    const value = request.replace(/\s+/g, " ").trim();
+    return value.length > 160 ? `${value.slice(0, 157)}...` : value;
+}
+function laterTimestamp(left, right) {
+    return right && right.localeCompare(left) > 0 ? right : left;
+}

package/dist/core/task-state-machine.js

@@ -0,0 +1,18 @@
+const TASK_STATE_TRANSITIONS = {
+    created: new Set(["routed", "paused", "failed", "cancelled"]),
+    routed: new Set(["judging", "paused", "failed", "cancelled"]),
+    judging: new Set(["ready_for_pair", "paused", "failed", "cancelled"]),
+    ready_for_pair: new Set(["actor_running", "paused", "done", "failed", "cancelled"]),
+    actor_running: new Set(["critic_running", "verifying", "paused", "failed", "cancelled"]),
+    critic_running: new Set(["revision_needed", "integrating", "paused", "failed", "cancelled"]),
+    revision_needed: new Set(["actor_running", "paused", "failed", "cancelled"]),
+    integrating: new Set(["actor_running", "verifying", "paused", "done", "failed", "cancelled"]),
+    verifying: new Set(["revision_needed", "integrating", "paused", "done", "failed", "cancelled"]),
+    paused: new Set(["routed", "judging", "ready_for_pair", "failed", "cancelled"]),
+    done: new Set(["routed", "cancelled"]),
+    failed: new Set(["routed", "judging", "ready_for_pair"]),
+    cancelled: new Set(["routed", "judging", "ready_for_pair"])
+};
+export function taskStateTransitionAllowed(from, to) {
+    return from === to || TASK_STATE_TRANSITIONS[from].has(to);
+}

package/dist/core/workspace-commit-recovery.js

@@ -0,0 +1,118 @@
+import { readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { sessionsRoot } from "./paths.js";
+const TASK_DIRECTORY_PATTERN = /^task-/;
+const TURN_DIRECTORY_PATTERN = /^turn-(\d{4,})$/;
+const WAVE_DIRECTORY_PATTERN = /^wave-(\d{4,})$/;
+const COMMIT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
+const COMMIT_PROTOCOL = "atomic-claim-v1";
+export async function reconcileWorkspaceCommitIntents(projectRoot, dataDir) {
+    const recovery = { cleaned: 0, preserved: 0 };
+    const taskEntries = await directoryEntries(sessionsRoot(projectRoot, dataDir));
+    for (const taskEntry of taskEntries) {
+        if (!taskEntry.isDirectory() || !TASK_DIRECTORY_PATTERN.test(taskEntry.name)) {
+            continue;
+        }
+        const workspacesDir = join(sessionsRoot(projectRoot, dataDir), taskEntry.name, "workspaces");
+        for (const turnEntry of await directoryEntries(workspacesDir)) {
+            const turnMatch = turnEntry.isDirectory() ? TURN_DIRECTORY_PATTERN.exec(turnEntry.name) : null;
+            if (!turnMatch) {
+                continue;
+            }
+            for (const waveEntry of await directoryEntries(join(workspacesDir, turnEntry.name))) {
+                const waveMatch = waveEntry.isDirectory() ? WAVE_DIRECTORY_PATTERN.exec(waveEntry.name) : null;
+                if (!waveMatch) {
+                    continue;
+                }
+                const waveDir = join(workspacesDir, turnEntry.name, waveEntry.name);
+                const pendingPath = join(waveDir, "integration.pending.json");
+                const pendingRecord = await readJsonRecord(pendingPath);
+                if (pendingRecord === undefined) {
+                    continue;
+                }
+                const pending = parseCommitEvidence(pendingRecord, "committing");
+                const integrated = parseCommitEvidence(await readJsonRecord(join(waveDir, "integration.json")), "integrated");
+                const directoryTurnId = turnMatch[1];
+                const directoryWave = Number(waveMatch[1]);
+                if (!pending
+                    || !integrated
+                    || pending.turnId !== directoryTurnId
+                    || pending.wave !== directoryWave
+                    || !sameCommit(pending, integrated)) {
+                    recovery.preserved += 1;
+                    continue;
+                }
+                try {
+                    await rm(pendingPath, { force: true });
+                    recovery.cleaned += 1;
+                }
+                catch {
+                    recovery.preserved += 1;
+                }
+            }
+        }
+    }
+    return recovery;
+}
+async function directoryEntries(path) {
+    try {
+        return await readdir(path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+async function readJsonRecord(path) {
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : null;
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? undefined : null;
+    }
+}
+function parseCommitEvidence(record, state) {
+    const featureIds = stringArray(record?.feature_ids);
+    const changedPaths = stringArray(record?.changed_paths);
+    const commitId = record?.commit_id;
+    const commitProtocol = record?.commit_protocol;
+    if (record?.version !== 1
+        || record.state !== state
+        || typeof record.turn_id !== "string"
+        || !Number.isInteger(record.wave)
+        || record.wave < 1
+        || !featureIds
+        || !changedPaths
+        || (commitId !== undefined && (typeof commitId !== "string" || !COMMIT_ID_PATTERN.test(commitId)))
+        || (commitProtocol !== undefined && commitProtocol !== COMMIT_PROTOCOL)) {
+        return null;
+    }
+    return {
+        version: 1,
+        state,
+        turnId: record.turn_id,
+        wave: record.wave,
+        featureIds,
+        ...(typeof commitId === "string" ? { commitId } : {}),
+        ...(commitProtocol === COMMIT_PROTOCOL ? { commitProtocol } : {}),
+        changedPaths
+    };
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? value
+        : null;
+}
+function sameCommit(pending, integrated) {
+    return pending.turnId === integrated.turnId
+        && pending.wave === integrated.wave
+        && sameStrings(pending.featureIds, integrated.featureIds)
+        && sameStrings(pending.changedPaths, integrated.changedPaths)
+        && (pending.commitId === undefined || pending.commitId === integrated.commitId)
+        && (pending.commitProtocol === undefined || pending.commitProtocol === integrated.commitProtocol);
+}
+function sameStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/core/workspace.js

@@ -2,9 +2,12 @@ import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { z } from "zod";
 import { ensureDir, pathExists, pathIsDirectory, readJson, readTextIfExists, writeJson, writeText } from "./file-store.js";
+import { runWithLeaseFinalization } from "./lease-finalization.js";
+import { acquireProcessMutationTurn } from "./process-mutation-turn.js";
 const lastWorkspaceFile = "last-workspace";
 const workspacesFile = "workspaces.json";
 const maxRememberedWorkspaces = 20;
+const workspaceRegistryIntentPrefix = ".workspace-registry-claim-";
 const WorkspaceRegistrySchema = z.object({
     version: z.literal(1).default(1),
     workspaces: z
@@ -73,18 +76,23 @@ export async function listWorkspaceChoices(appRoot) {
         .map(({ selectable: _selectable, ...choice }) => choice);
 }
 async function rememberWorkspace(appRoot, workspaceRoot) {
-    const now = new Date().toISOString();
     const resolved = resolveWorkspacePath(process.cwd(), workspaceRoot);
-    const current = await readWorkspaceEntries(appRoot);
-    const next = {
-        version: 1,
-        workspaces: [
-            { path: resolved, last_used_at: now },
-            ...current.filter((entry) => resolveStoredWorkspacePath(appRoot, entry.path) !== resolved)
-        ].slice(0, maxRememberedWorkspaces)
-    };
-    await writeText(lastWorkspacePath(appRoot), `${resolved}\n`);
-    await writeJson(workspacesPath(appRoot), WorkspaceRegistrySchema.parse(next));
+    const mutationTurn = await acquireProcessMutationTurn(join(appRoot, ".parallel-codex"), {
+        intentPrefix: workspaceRegistryIntentPrefix,
+        timeoutMessage: "Timed out waiting to update the workspace registry."
+    });
+    await runWithLeaseFinalization("Workspace registry update", mutationTurn, async () => {
+        const current = await readWorkspaceEntries(appRoot);
+        const next = {
+            version: 1,
+            workspaces: [
+                { path: resolved, last_used_at: new Date().toISOString() },
+                ...current.filter((entry) => resolveStoredWorkspacePath(appRoot, entry.path) !== resolved)
+            ].slice(0, maxRememberedWorkspaces)
+        };
+        await writeJson(workspacesPath(appRoot), WorkspaceRegistrySchema.parse(next));
+        await writeText(lastWorkspacePath(appRoot), `${resolved}\n`);
+    });
 }
 async function readWorkspaceEntries(appRoot) {
     const file = workspacesPath(appRoot);