parallel-codex-tui 0.1.4 → 0.1.6

package/dist/core/session-index.js

@@ -1,79 +1,77 @@
-import { readdir } from "node:fs/promises";
+import { copyFile, readdir, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { NativeSessionSchema, RetiredNativeSessionSchema, RouteDecisionSchema, TaskIdSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
 import { ensureDir, pathExists, readJson, readTextIfExists } from "./file-store.js";
+const SESSION_INDEX_SCHEMA_VERSION = 2;
+const SESSION_INDEX_FILENAME = "session-index.sqlite";
 export class SessionIndex {
     db;
     projectRoot;
     dataDir;
-    constructor(db, projectRoot, dataDir) {
+    databasePath;
+    recovery;
+    constructor(db, projectRoot, dataDir, databasePath, recovery) {
         this.db = db;
         this.projectRoot = projectRoot;
         this.dataDir = dataDir;
+        this.databasePath = databasePath;
+        this.recovery = recovery;
     }
     static async open(projectRoot, dataDir) {
-        await ensureDir(join(projectRoot, dataDir));
-        const index = new SessionIndex(new DatabaseSync(join(projectRoot, dataDir, "session-index.sqlite")), projectRoot, dataDir);
-        index.initialize();
-        return index;
+        const runtimeDir = join(projectRoot, dataDir);
+        const databasePath = join(runtimeDir, SESSION_INDEX_FILENAME);
+        const recoveryBackupPath = `${databasePath}.backup`;
+        await ensureDir(runtimeDir);
+        const databaseExisted = await pathExists(databasePath);
+        const opened = await openSessionDatabase(databasePath, recoveryBackupPath);
+        const index = new SessionIndex(opened.db, projectRoot, dataDir, databasePath, opened.recovery);
+        try {
+            const previousVersion = index.schemaVersion();
+            if (databaseExisted && previousVersion < SESSION_INDEX_SCHEMA_VERSION) {
+                await index.writeBackup(`${databasePath}.pre-migration-v${previousVersion}.backup`);
+            }
+            index.initialize();
+            await index.writeBackup(recoveryBackupPath);
+            return index;
+        }
+        catch (error) {
+            try {
+                index.close();
+            }
+            catch {
+                // Preserve the migration or backup failure that prevented startup.
+            }
+            throw error;
+        }
     }
     initialize() {
-        this.db.exec(`
-      PRAGMA busy_timeout = 5000;
-
-      CREATE TABLE IF NOT EXISTS tasks (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        cwd TEXT NOT NULL,
-        mode TEXT NOT NULL,
-        status TEXT NOT NULL,
-        archived_at TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS turns (
-        task_id TEXT NOT NULL,
-        turn_id TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        request_path TEXT NOT NULL,
-        PRIMARY KEY (task_id, turn_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS workers (
-        task_id TEXT NOT NULL,
-        worker_id TEXT NOT NULL,
-        role TEXT NOT NULL,
-        engine TEXT NOT NULL,
-        state TEXT NOT NULL,
-        phase TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        status_path TEXT NOT NULL,
-        output_log_path TEXT NOT NULL,
-        dir TEXT NOT NULL,
-        native_session_id TEXT,
-        PRIMARY KEY (task_id, worker_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS native_sessions (
-        task_id TEXT NOT NULL,
-        worker_id TEXT NOT NULL,
-        engine TEXT NOT NULL,
-        role TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        cwd TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        last_used_at TEXT NOT NULL,
-        source TEXT NOT NULL,
-        PRIMARY KEY (task_id, worker_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS workspace_state (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-        this.ensureColumn("tasks", "archived_at", "TEXT");
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const currentVersion = this.schemaVersion();
+            if (currentVersion > SESSION_INDEX_SCHEMA_VERSION) {
+                throw new Error(`Session index schema v${currentVersion} is newer than supported v${SESSION_INDEX_SCHEMA_VERSION}`);
+            }
+            for (let targetVersion = currentVersion + 1; targetVersion <= SESSION_INDEX_SCHEMA_VERSION; targetVersion += 1) {
+                this.applyMigration(targetVersion);
+                this.db.exec(`PRAGMA user_version = ${targetVersion}`);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch {
+                // Preserve the migration failure if SQLite already rolled the transaction back.
+            }
+            throw error;
+        }
+        assertHealthyDatabase(this.db);
+    }
+    schemaVersion() {
+        const row = this.db.prepare("PRAGMA user_version").get();
+        return Number(row?.user_version) || 0;
     }
     async upsertTask(task) {
         this.db
@@ -260,6 +258,7 @@ export class SessionIndex {
             }
             throw error;
         }
+        await this.writeBackup(`${this.databasePath}.backup`);
     }
     close() {
         this.db.close();
@@ -277,6 +276,78 @@ export class SessionIndex {
             }
         }
     }
+    applyMigration(targetVersion) {
+        if (targetVersion === 1) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tasks (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          cwd TEXT NOT NULL,
+          mode TEXT NOT NULL,
+          status TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS turns (
+          task_id TEXT NOT NULL,
+          turn_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          request_path TEXT NOT NULL,
+          PRIMARY KEY (task_id, turn_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS workers (
+          task_id TEXT NOT NULL,
+          worker_id TEXT NOT NULL,
+          role TEXT NOT NULL,
+          engine TEXT NOT NULL,
+          state TEXT NOT NULL,
+          phase TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          status_path TEXT NOT NULL,
+          output_log_path TEXT NOT NULL,
+          dir TEXT NOT NULL,
+          native_session_id TEXT,
+          PRIMARY KEY (task_id, worker_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS native_sessions (
+          task_id TEXT NOT NULL,
+          worker_id TEXT NOT NULL,
+          engine TEXT NOT NULL,
+          role TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          cwd TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          last_used_at TEXT NOT NULL,
+          source TEXT NOT NULL,
+          PRIMARY KEY (task_id, worker_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS workspace_state (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+      `);
+            return;
+        }
+        if (targetVersion === 2) {
+            this.ensureColumn("tasks", "archived_at", "TEXT");
+            return;
+        }
+        throw new Error(`Missing session index migration for schema v${targetVersion}`);
+    }
+    async writeBackup(targetPath) {
+        const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+        try {
+            this.db.prepare("VACUUM INTO ?").run(tempPath);
+            await replaceFile(tempPath, targetPath);
+        }
+        catch (error) {
+            await rm(tempPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
     tableHasColumn(table, column) {
         const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
         return columns.some((entry) => entry.name === column);
@@ -362,6 +433,108 @@ export class SessionIndex {
         return retired?.session_id === active.session_id ? null : active;
     }
 }
+async function openSessionDatabase(databasePath, backupPath) {
+    let db = null;
+    try {
+        db = openCheckedDatabase(databasePath);
+        return { db, recovery: null };
+    }
+    catch (primaryError) {
+        try {
+            db?.close();
+        }
+        catch {
+            // Continue into file-backed recovery.
+        }
+        const backupIsHealthy = await isHealthyDatabaseFile(backupPath);
+        const quarantinedPath = await quarantineDatabase(databasePath);
+        await Promise.all([
+            rm(`${databasePath}-wal`, { force: true }),
+            rm(`${databasePath}-shm`, { force: true })
+        ]);
+        if (backupIsHealthy) {
+            await copyFile(backupPath, databasePath);
+        }
+        try {
+            return {
+                db: openCheckedDatabase(databasePath),
+                recovery: {
+                    source: backupIsHealthy ? "backup" : "empty",
+                    quarantinedPath
+                }
+            };
+        }
+        catch (recoveryError) {
+            throw new AggregateError([primaryError, recoveryError], `Unable to open or recover session index: ${databasePath}`);
+        }
+    }
+}
+function openCheckedDatabase(path) {
+    const db = new DatabaseSync(path);
+    try {
+        db.exec("PRAGMA busy_timeout = 5000");
+        assertHealthyDatabase(db);
+        return db;
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Preserve the database validation failure.
+        }
+        throw error;
+    }
+}
+function assertHealthyDatabase(db) {
+    const rows = db.prepare("PRAGMA quick_check").all();
+    if (rows.length !== 1
+        || Object.values(rows[0] ?? {}).length !== 1
+        || Object.values(rows[0] ?? {})[0] !== "ok") {
+        throw new Error(`Session index integrity check failed: ${JSON.stringify(rows)}`);
+    }
+}
+async function isHealthyDatabaseFile(path) {
+    if (!(await pathExists(path))) {
+        return false;
+    }
+    let db = null;
+    try {
+        db = new DatabaseSync(path);
+        assertHealthyDatabase(db);
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            // A failed validation can leave no open handle to close.
+        }
+    }
+}
+async function quarantineDatabase(path) {
+    const quarantinedPath = `${path}.corrupt-${Date.now()}-${process.pid}`;
+    if (await pathExists(path)) {
+        await rename(path, quarantinedPath);
+    }
+    return quarantinedPath;
+}
+async function replaceFile(source, target) {
+    try {
+        await rename(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST" && error.code !== "EPERM") {
+            throw error;
+        }
+        await rm(target, { force: true });
+        await rename(source, target);
+    }
+}
 async function readJsonIfValid(path, schema) {
     if (!(await pathExists(path))) {
         return null;

package/dist/core/session-manager.js

@@ -27,7 +27,7 @@ export class InterruptedTaskRecoveryBlockedError extends Error {
         this.name = "InterruptedTaskRecoveryBlockedError";
     }
 }
-const TERMINAL_TASK_STATES = new Set(["done", "failed", "cancelled"]);
+const TERMINAL_TASK_STATES = new Set(["done", "paused", "failed", "cancelled"]);
 const ACTIVE_WORKER_STATES = new Set(["idle", "starting", "running", "waiting"]);
 const ACTIVE_FEATURE_STATES = new Set([
     "queued",
@@ -41,6 +41,19 @@ const ACTIVE_FEATURE_STATES = new Set([
 ]);
 const PENDING_TURN_DIRECTORY = /^\.turn-(\d{4})-.+\.pending$/;
 const PENDING_TASK_CREATION_CLAIM = /^\.(task-.+)\.creating\.json$/;
+const CompletionContractSchema = z.object({
+    version: z.literal(1),
+    final_judge_required: z.literal(true)
+});
+const FinalAcceptanceEvidenceSchema = z.object({
+    decision: z.literal("approved")
+}).passthrough();
+const FinalAcceptanceValidationSchema = z.object({
+    version: z.literal(1),
+    state: z.literal("valid"),
+    decision: z.literal("approved"),
+    issues: z.array(z.string()).length(0)
+});
 const TaskCreationOwnerSchema = z.object({
     version: z.literal(1),
     task_id: TaskIdSchema,
@@ -852,6 +865,17 @@ export class SessionManager {
         if (!(await readTextIfExists(join(latestTurn.dir, "supervisor-summary.md"))).trim()) {
             return false;
         }
+        const completionContractPath = join(latestTurn.dir, "completion-contract.json");
+        if (await pathExists(completionContractPath)) {
+            try {
+                await readJson(completionContractPath, CompletionContractSchema);
+                await readJson(join(latestTurn.dir, "final-acceptance.json"), FinalAcceptanceEvidenceSchema);
+                await readJson(join(latestTurn.dir, "final-acceptance-validation.json"), FinalAcceptanceValidationSchema);
+            }
+            catch {
+                return false;
+            }
+        }
         const featuresRoot = join(task.dir, "features");
         if (!(await pathExists(featuresRoot))) {
             return true;

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

@@ -1,13 +1,14 @@
 const TASK_STATE_TRANSITIONS = {
-    created: new Set(["routed", "failed", "cancelled"]),
-    routed: new Set(["judging", "failed", "cancelled"]),
-    judging: new Set(["ready_for_pair", "failed", "cancelled"]),
-    ready_for_pair: new Set(["actor_running", "done", "failed", "cancelled"]),
-    actor_running: new Set(["critic_running", "verifying", "failed", "cancelled"]),
-    critic_running: new Set(["revision_needed", "integrating", "failed", "cancelled"]),
-    revision_needed: new Set(["actor_running", "failed", "cancelled"]),
-    integrating: new Set(["actor_running", "verifying", "done", "failed", "cancelled"]),
-    verifying: new Set(["revision_needed", "integrating", "failed", "cancelled"]),
+    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"])