@exaudeus/workrail 3.37.1 → 3.39.0

package/dist/cli/commands/index.d.ts

@@ -12,3 +12,4 @@ export { executeWorktrainInboxCommand, type OutboxMessage, type InboxCursor, typ
 export { executeWorktrainSpawnCommand, type WorktrainSpawnCommandDeps, type WorktrainSpawnCommandOpts, } from './worktrain-spawn.js';
 export { executeWorktrainAwaitCommand, parseDurationMs, type WorktrainAwaitCommandDeps, type WorktrainAwaitCommandOpts, type SessionOutcome, type SessionResult, type AwaitResult, } from './worktrain-await.js';
 export { executeWorktrainDaemonCommand, type WorktrainDaemonCommandDeps, type WorktrainDaemonCommandOpts, } from './worktrain-daemon.js';
+export { executeWorktrainOverviewCommand, buildConsoleServiceFromDataDir, type WorktrainOverviewCommandDeps, type WorktrainOverviewCommandOpts, type StatusDataPacket, type StatusSession, } from './worktrain-overview.js';

package/dist/cli/commands/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeWorktrainDaemonCommand = exports.parseDurationMs = exports.executeWorktrainAwaitCommand = exports.executeWorktrainSpawnCommand = exports.executeWorktrainInboxCommand = exports.executeWorktrainTellCommand = exports.executeWorktrainInitCommand = exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeVersionCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitConfigCommand = exports.executeInitCommand = void 0;
+exports.buildConsoleServiceFromDataDir = exports.executeWorktrainOverviewCommand = exports.executeWorktrainDaemonCommand = exports.parseDurationMs = exports.executeWorktrainAwaitCommand = exports.executeWorktrainSpawnCommand = exports.executeWorktrainInboxCommand = exports.executeWorktrainTellCommand = exports.executeWorktrainInitCommand = exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeVersionCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitConfigCommand = exports.executeInitCommand = void 0;
 var init_js_1 = require("./init.js");
 Object.defineProperty(exports, "executeInitCommand", { enumerable: true, get: function () { return init_js_1.executeInitCommand; } });
 Object.defineProperty(exports, "executeInitConfigCommand", { enumerable: true, get: function () { return init_js_1.executeInitConfigCommand; } });
@@ -35,3 +35,6 @@ Object.defineProperty(exports, "executeWorktrainAwaitCommand", { enumerable: tru
 Object.defineProperty(exports, "parseDurationMs", { enumerable: true, get: function () { return worktrain_await_js_1.parseDurationMs; } });
 var worktrain_daemon_js_1 = require("./worktrain-daemon.js");
 Object.defineProperty(exports, "executeWorktrainDaemonCommand", { enumerable: true, get: function () { return worktrain_daemon_js_1.executeWorktrainDaemonCommand; } });
+var worktrain_overview_js_1 = require("./worktrain-overview.js");
+Object.defineProperty(exports, "executeWorktrainOverviewCommand", { enumerable: true, get: function () { return worktrain_overview_js_1.executeWorktrainOverviewCommand; } });
+Object.defineProperty(exports, "buildConsoleServiceFromDataDir", { enumerable: true, get: function () { return worktrain_overview_js_1.buildConsoleServiceFromDataDir; } });

package/dist/cli/commands/worktrain-overview.d.ts

@@ -0,0 +1,32 @@
+import { ConsoleService } from '../../v2/usecases/console-service.js';
+export interface StatusSession {
+    readonly sessionId: string;
+    readonly title: string;
+    readonly status: 'active' | 'recent';
+    readonly rawStatus: string;
+    readonly stepLabel: string | null;
+    readonly lastModifiedMs: number;
+    readonly isComplete: boolean;
+}
+export interface StatusDataPacket {
+    readonly asOfMs: number;
+    readonly activeSessions: readonly StatusSession[];
+    readonly recentSessions: readonly StatusSession[];
+    readonly isDaemonless: true;
+}
+export interface WorktrainOverviewCommandDeps {
+    readonly now: () => number;
+    readonly buildConsoleService: (dataDir: string) => ConsoleService;
+    readonly homedir: () => string;
+    readonly joinPath: (...parts: string[]) => string;
+    readonly print: (line: string) => void;
+    readonly getDataDirEnv: () => string | undefined;
+}
+export interface WorktrainOverviewCommandOpts {
+    readonly json?: boolean;
+    readonly workspace?: string;
+    readonly activeThresholdMs?: number;
+    readonly recentWindowMs?: number;
+}
+export declare function executeWorktrainOverviewCommand(deps: WorktrainOverviewCommandDeps, opts?: WorktrainOverviewCommandOpts): Promise<void>;
+export declare function buildConsoleServiceFromDataDir(dataDir: string): ConsoleService;

package/dist/cli/commands/worktrain-overview.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorktrainOverviewCommand = executeWorktrainOverviewCommand;
+exports.buildConsoleServiceFromDataDir = buildConsoleServiceFromDataDir;
+const index_js_1 = require("../../v2/infra/local/data-dir/index.js");
+const index_js_2 = require("../../v2/infra/local/directory-listing/index.js");
+const index_js_3 = require("../../v2/infra/local/fs/index.js");
+const index_js_4 = require("../../v2/infra/local/sha256/index.js");
+const index_js_5 = require("../../v2/infra/local/crypto/index.js");
+const index_js_6 = require("../../v2/infra/local/snapshot-store/index.js");
+const index_js_7 = require("../../v2/infra/local/pinned-workflow-store/index.js");
+const index_js_8 = require("../../v2/infra/local/session-store/index.js");
+const console_service_js_1 = require("../../v2/usecases/console-service.js");
+const DEFAULT_ACTIVE_THRESHOLD_MS = 2 * 60 * 60 * 1000;
+const DEFAULT_RECENT_WINDOW_MS = 24 * 60 * 60 * 1000;
+function formatRelativeTime(deltaMs) {
+    const totalMinutes = Math.floor(deltaMs / 60000);
+    if (totalMinutes < 60)
+        return `${totalMinutes}m ago`;
+    const hours = Math.floor(totalMinutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function formatRunningTime(deltaMs) {
+    const totalMinutes = Math.floor(deltaMs / 60000);
+    if (totalMinutes < 60)
+        return `running ${totalMinutes}m`;
+    const hours = Math.floor(totalMinutes / 60);
+    return `running ${hours}h`;
+}
+function buildSessionTitle(s) {
+    if (s.sessionTitle && s.sessionTitle.trim().length > 0) {
+        return s.sessionTitle.trim();
+    }
+    if (s.workflowName && s.workflowName.trim().length > 0) {
+        return s.workflowName.trim();
+    }
+    if (s.workflowId && s.workflowId.trim().length > 0) {
+        return s.workflowId.trim();
+    }
+    return String(s.sessionId).slice(0, 20) + '...';
+}
+function extractStepLabel(_s) {
+    return null;
+}
+function isCompleted(s) {
+    return s.status === 'complete' || s.status === 'complete_with_gaps';
+}
+function isInProgress(s) {
+    return s.status === 'in_progress' || s.status === 'blocked' || s.status === 'dormant';
+}
+async function executeWorktrainOverviewCommand(deps, opts = {}) {
+    const nowMs = deps.now();
+    const activeThresholdMs = opts.activeThresholdMs ?? DEFAULT_ACTIVE_THRESHOLD_MS;
+    const recentWindowMs = opts.recentWindowMs ?? DEFAULT_RECENT_WINDOW_MS;
+    const dataDir = deps.getDataDirEnv()
+        ?? deps.joinPath(deps.homedir(), '.workrail', 'data');
+    const consoleService = deps.buildConsoleService(dataDir);
+    const sessionListResult = await consoleService.getSessionList();
+    const sessions = sessionListResult.isOk() ? sessionListResult.value.sessions : [];
+    const activeSessions = [];
+    const recentSessions = [];
+    for (const s of sessions) {
+        const lastMod = s.lastModifiedMs;
+        const age = nowMs - lastMod;
+        if (isInProgress(s) && age <= activeThresholdMs) {
+            activeSessions.push({
+                sessionId: String(s.sessionId),
+                title: buildSessionTitle(s),
+                status: 'active',
+                rawStatus: s.status,
+                stepLabel: extractStepLabel(s),
+                lastModifiedMs: lastMod,
+                isComplete: false,
+            });
+        }
+        else if (isCompleted(s) && age <= recentWindowMs) {
+            recentSessions.push({
+                sessionId: String(s.sessionId),
+                title: buildSessionTitle(s),
+                status: 'recent',
+                rawStatus: s.status,
+                stepLabel: extractStepLabel(s),
+                lastModifiedMs: lastMod,
+                isComplete: true,
+            });
+        }
+    }
+    activeSessions.sort((a, b) => b.lastModifiedMs - a.lastModifiedMs);
+    recentSessions.sort((a, b) => b.lastModifiedMs - a.lastModifiedMs);
+    const packet = {
+        asOfMs: nowMs,
+        activeSessions,
+        recentSessions,
+        isDaemonless: true,
+    };
+    if (opts.json) {
+        deps.print(JSON.stringify(packet, null, 2));
+        return;
+    }
+    const date = new Date(nowMs);
+    const dateStr = date.toLocaleDateString('en-US', {
+        weekday: 'short',
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric',
+    });
+    const timeStr = date.toLocaleTimeString('en-US', {
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    });
+    deps.print(`WorkTrain  [${dateStr}  ${timeStr}]`);
+    deps.print('Note: live session detection requires daemon (showing last-known state).');
+    deps.print('');
+    if (activeSessions.length === 0 && recentSessions.length === 0) {
+        deps.print('No recent sessions. Run `worktrain daemon` to start.');
+        return;
+    }
+    if (activeSessions.length > 0) {
+        deps.print(`ACTIVE (${activeSessions.length} session${activeSessions.length !== 1 ? 's' : ''})`);
+        for (const s of activeSessions) {
+            const runningStr = formatRunningTime(nowMs - s.lastModifiedMs);
+            deps.print(`  ${s.rawStatus}  ${s.title}`);
+            if (s.stepLabel) {
+                deps.print(`               Step -- ${s.stepLabel}  --  ${runningStr}`);
+            }
+            else {
+                deps.print(`               ${runningStr}`);
+            }
+            deps.print('');
+        }
+    }
+    if (recentSessions.length > 0) {
+        deps.print(`RECENT (last 24h, ${recentSessions.length} completed)`);
+        for (const s of recentSessions) {
+            const agoStr = formatRelativeTime(nowMs - s.lastModifiedMs);
+            deps.print(`  done  ${s.title}    ${agoStr}`);
+        }
+        deps.print('');
+    }
+    deps.print('Run `worktrain console` for full session details.');
+}
+function buildConsoleServiceFromDataDir(dataDir) {
+    const envWithDataDir = {
+        ...process.env,
+        WORKRAIL_DATA_DIR: dataDir,
+    };
+    const dataDirPort = new index_js_1.LocalDataDirV2(envWithDataDir);
+    const fsPort = new index_js_3.NodeFileSystemV2();
+    const sha256 = new index_js_4.NodeSha256V2();
+    const crypto = new index_js_5.NodeCryptoV2();
+    const directoryListing = new index_js_2.LocalDirectoryListingV2(fsPort);
+    const sessionStore = new index_js_8.LocalSessionEventLogStoreV2(dataDirPort, fsPort, sha256);
+    const snapshotStore = new index_js_6.LocalSnapshotStoreV2(dataDirPort, fsPort, crypto);
+    const pinnedWorkflowStore = new index_js_7.LocalPinnedWorkflowStoreV2(dataDirPort, fsPort);
+    return new console_service_js_1.ConsoleService({
+        directoryListing,
+        dataDir: dataDirPort,
+        sessionStore,
+        snapshotStore,
+        pinnedWorkflowStore,
+    });
+}

package/dist/cli-worktrain.js

@@ -522,9 +522,9 @@ program
     }
 });
 program
-    .command('status <sessionId>')
+    .command('health <sessionId>')
     .description('Print a health summary for a daemon session. Accepts sessionId (UUID prefix) or workrailSessionId (sess_xxx).')
-    .action(async (sessionId) => {
+    .action((sessionId) => {
     if (sessionId.length < 20) {
         process.stderr.write(`Warning: session ID "${sessionId}" is shorter than 20 characters -- ` +
             `provide more characters to avoid matching multiple sessions.\n`);
@@ -540,6 +540,50 @@ program
         process.stdout.write(`No events today. Is the daemon running? (Expected: ${filePath})\n`);
         return;
     }
+    runHealthSummary(sessionId, raw);
+});
+program
+    .command('status [sessionId]')
+    .description('Print an overview of active and recently completed sessions (no args), ' +
+    'or a session health summary when a sessionId is provided (deprecated: use `worktrain health <id>`).')
+    .option('--json', 'Output machine-readable JSON packet')
+    .option('-w, --workspace <path>', 'Filter sessions by workspace (reserved for future use)')
+    .action(async (sessionId, options) => {
+    if (sessionId !== undefined) {
+        process.stderr.write(`Deprecation notice: \`worktrain status <sessionId>\` has been renamed to \`worktrain health <sessionId>\`.\n` +
+            `Please update your scripts to use \`worktrain health ${sessionId}\`.\n\n`);
+        if (sessionId.length < 20) {
+            process.stderr.write(`Warning: session ID "${sessionId}" is shorter than 20 characters -- ` +
+                `provide more characters to avoid matching multiple sessions.\n`);
+        }
+        const eventsDir = path_1.default.join(os_1.default.homedir(), '.workrail', 'events', 'daemon');
+        const date = new Date().toISOString().slice(0, 10);
+        const filePath = path_1.default.join(eventsDir, `${date}.jsonl`);
+        let raw;
+        try {
+            raw = fs_1.default.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            process.stdout.write(`No events today. Is the daemon running? (Expected: ${filePath})\n`);
+            return;
+        }
+        process.stderr.write(`\nNote: This is the old \`worktrain status <id>\` output. Use \`worktrain health <id>\` instead.\n\n`);
+        runHealthSummary(sessionId, raw);
+        return;
+    }
+    await (0, index_js_1.executeWorktrainOverviewCommand)({
+        now: () => Date.now(),
+        buildConsoleService: index_js_1.buildConsoleServiceFromDataDir,
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        print: (line) => process.stdout.write(line + '\n'),
+        getDataDirEnv: () => process.env['WORKRAIL_DATA_DIR'],
+    }, {
+        json: options.json,
+        workspace: options.workspace,
+    });
+});
+function runHealthSummary(sessionId, raw) {
     let workflowId = null;
     let firstTs = null;
     let lastTs = null;
@@ -657,5 +701,212 @@ program
         process.stdout.write(`*** WARNING: ${llmTurns} turns with 0 step advances (possible stuck)\n`);
     }
     process.stdout.write('\n');
+}
+const runCommand = program
+    .command('run')
+    .description('Run a coordinator script');
+runCommand
+    .command('pr-review')
+    .description('Review open PRs autonomously: dispatch review sessions, route by findings, merge or escalate')
+    .requiredOption('-W, --workspace <path>', 'Absolute path to the git workspace')
+    .option('-r, --pr <number>', 'Review a specific PR number (repeatable)', (val, prev) => [...prev, parseInt(val, 10)], [])
+    .option('--dry-run', 'Print actions without dispatching sessions or merging')
+    .option('-p, --port <n>', 'Console HTTP server port (default: auto-discover from lock file, then 3456)', parseInt)
+    .action(async (options) => {
+    const { runPrReviewCoordinator, discoverConsolePort, } = await Promise.resolve().then(() => __importStar(require('./coordinators/pr-review.js')));
+    const { execFile: execFileRaw } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const execFilePromise = (0, util_1.promisify)(execFileRaw);
+    if (!path_1.default.isAbsolute(options.workspace)) {
+        process.stderr.write(`Error: --workspace must be an absolute path, got: ${options.workspace}\n`);
+        process.exit(1);
+    }
+    try {
+        const stat = await fs_1.default.promises.stat(options.workspace);
+        if (!stat.isDirectory()) {
+            process.stderr.write(`Error: --workspace must be an existing directory: ${options.workspace}\n`);
+            process.exit(1);
+        }
+    }
+    catch {
+        process.stderr.write(`Error: --workspace does not exist: ${options.workspace}\n`);
+        process.exit(1);
+    }
+    const port = await discoverConsolePort({
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+    }, options.port);
+    const deps = {
+        spawnSession: async (workflowId, goal, workspace) => {
+            const url = `http://127.0.0.1:${port}/api/v2/auto/dispatch`;
+            try {
+                const response = await globalThis.fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ workflowId, goal, workspacePath: workspace }),
+                    signal: AbortSignal.timeout(30000),
+                });
+                const body = await response.json();
+                if (!response.ok) {
+                    const errMsg = typeof body['error'] === 'string' ? body['error'] : `HTTP ${response.status}`;
+                    if (response.status === 503) {
+                        return { kind: 'err', error: `WorkTrain daemon is not ready: ${errMsg}` };
+                    }
+                    return { kind: 'err', error: `Dispatch failed: ${errMsg}` };
+                }
+                if (body['success'] !== true || typeof body['data'] !== 'object') {
+                    return { kind: 'err', error: 'Unexpected response from dispatch endpoint' };
+                }
+                const data = body['data'];
+                const handle = typeof data['sessionHandle'] === 'string' ? data['sessionHandle'] : '';
+                if (!handle) {
+                    return { kind: 'err', error: 'Dispatch succeeded but no session handle returned' };
+                }
+                return { kind: 'ok', value: handle };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                const isConnRefused = msg.includes('ECONNREFUSED') || msg.includes('fetch failed');
+                if (isConnRefused) {
+                    return { kind: 'err', error: `Could not connect to WorkTrain daemon on port ${port}. Ensure the daemon is running with: worktrain daemon` };
+                }
+                if (e instanceof Error && e.name === 'TimeoutError') {
+                    return { kind: 'err', error: `Daemon request timed out after 30s` };
+                }
+                return { kind: 'err', error: `Dispatch request failed: ${msg}` };
+            }
+        },
+        awaitSessions: async (handles, timeoutMs) => {
+            const { executeWorktrainAwaitCommand } = await Promise.resolve().then(() => __importStar(require('./cli/commands/worktrain-await.js')));
+            let resolvedResult = null;
+            await executeWorktrainAwaitCommand({
+                fetch: (url) => globalThis.fetch(url),
+                readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+                stdout: (line) => {
+                    try {
+                        resolvedResult = JSON.parse(line);
+                    }
+                    catch { }
+                },
+                stderr: (line) => process.stderr.write(line + '\n'),
+                homedir: os_1.default.homedir,
+                joinPath: path_1.default.join,
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                now: () => Date.now(),
+            }, {
+                sessions: [...handles].join(','),
+                mode: 'all',
+                timeout: `${Math.round(timeoutMs / 1000)}s`,
+                port,
+            });
+            if (resolvedResult === null) {
+                process.stderr.write(`[WARN coord:reason=await_failed] awaitSessions: could not get session results -- daemon may be unreachable or timed out. Returning all ${handles.length} session(s) as failed.\n`);
+            }
+            return resolvedResult ?? { results: [...handles].map((h) => ({
+                    handle: h,
+                    outcome: 'failed',
+                    status: null,
+                    durationMs: 0,
+                })), allSucceeded: false };
+        },
+        getAgentResult: async (sessionHandle) => {
+            try {
+                const sessionUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(sessionHandle)}`;
+                const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(30000) });
+                if (!sessionRes.ok) {
+                    process.stderr.write(`[WARN coord:reason=http_error status=${sessionRes.status} handle=${sessionHandle.slice(0, 16)}] getAgentResult: session fetch returned HTTP ${sessionRes.status}\n`);
+                    return null;
+                }
+                const sessionBody = await sessionRes.json();
+                if (sessionBody['success'] !== true) {
+                    process.stderr.write(`[WARN coord:reason=api_error handle=${sessionHandle.slice(0, 16)}] getAgentResult: session API returned success=false\n`);
+                    return null;
+                }
+                const data = sessionBody['data'];
+                if (!data) {
+                    process.stderr.write(`[WARN coord:reason=no_data handle=${sessionHandle.slice(0, 16)}] getAgentResult: session response missing data field\n`);
+                    return null;
+                }
+                const runs = data['runs'];
+                if (!Array.isArray(runs) || runs.length === 0) {
+                    process.stderr.write(`[WARN coord:reason=no_runs handle=${sessionHandle.slice(0, 16)}] getAgentResult: session has no runs\n`);
+                    return null;
+                }
+                const firstRun = runs[0];
+                const tipNodeId = typeof firstRun['preferredTipNodeId'] === 'string'
+                    ? firstRun['preferredTipNodeId']
+                    : null;
+                if (!tipNodeId) {
+                    process.stderr.write(`[WARN coord:reason=no_tip_node handle=${sessionHandle.slice(0, 16)}] getAgentResult: session run has no preferredTipNodeId\n`);
+                    return null;
+                }
+                const nodeUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(sessionHandle)}/nodes/${encodeURIComponent(tipNodeId)}`;
+                const nodeRes = await globalThis.fetch(nodeUrl, { signal: AbortSignal.timeout(30000) });
+                if (!nodeRes.ok) {
+                    process.stderr.write(`[WARN coord:reason=node_http_error status=${nodeRes.status} handle=${sessionHandle.slice(0, 16)} node=${tipNodeId.slice(0, 16)}] getAgentResult: node fetch returned HTTP ${nodeRes.status}\n`);
+                    return null;
+                }
+                const nodeBody = await nodeRes.json();
+                if (nodeBody['success'] !== true) {
+                    process.stderr.write(`[WARN coord:reason=node_api_error handle=${sessionHandle.slice(0, 16)} node=${tipNodeId.slice(0, 16)}] getAgentResult: node API returned success=false\n`);
+                    return null;
+                }
+                const nodeData = nodeBody['data'];
+                if (!nodeData) {
+                    process.stderr.write(`[WARN coord:reason=no_node_data handle=${sessionHandle.slice(0, 16)} node=${tipNodeId.slice(0, 16)}] getAgentResult: node response missing data field\n`);
+                    return null;
+                }
+                const recap = typeof nodeData['recapMarkdown'] === 'string' ? nodeData['recapMarkdown'] : null;
+                if (recap === null) {
+                    process.stderr.write(`[WARN coord:reason=no_recap handle=${sessionHandle.slice(0, 16)} node=${tipNodeId.slice(0, 16)}] getAgentResult: node has no recapMarkdown\n`);
+                }
+                return recap;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                return null;
+            }
+        },
+        listOpenPRs: async (workspace) => {
+            try {
+                const { stdout } = await execFilePromise('gh', ['pr', 'list', '--json', 'number,title,headRefName'], {
+                    cwd: workspace,
+                    timeout: 30000,
+                });
+                const parsed = JSON.parse(stdout);
+                return parsed.map((p) => ({ number: p.number, title: p.title, headRef: p.headRefName }));
+            }
+            catch {
+                return [];
+            }
+        },
+        mergePR: async (prNumber, workspace) => {
+            try {
+                await execFilePromise('gh', ['pr', 'merge', String(prNumber), '--squash', '--auto'], {
+                    cwd: workspace,
+                    timeout: 60000,
+                });
+                return { kind: 'ok', value: undefined };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'err', error: msg };
+            }
+        },
+        writeFile: async (filePath, content) => {
+            await fs_1.default.promises.writeFile(filePath, content, 'utf-8');
+        },
+        stderr: (line) => process.stderr.write(line + '\n'),
+        now: () => Date.now(),
+        port,
+    };
+    const result = await runPrReviewCoordinator(deps, {
+        workspace: options.workspace,
+        prs: options.pr.length > 0 ? options.pr : undefined,
+        dryRun: options.dryRun ?? false,
+        port: options.port,
+    });
+    process.exit(result.hasErrors ? 1 : 0);
 });
 program.parse();