parallel-codex-tui 0.1.0

package/dist/orchestrator/orchestrator.js

@@ -0,0 +1,545 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureDir, pathExists, readJson, readTextIfExists, writeJson, writeText } from "../core/file-store.js";
+import { routeRequestWithCodex } from "../core/router.js";
+import { TaskMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
+import { getAdapter } from "../workers/registry.js";
+import { appendFeatureDialogue, createFeatureChannel, featurePromptContext, updateFeatureStatus, writeFeatureDecision } from "./collaboration-channel.js";
+import { buildActorPrompt, buildCriticPrompt, buildJudgePrompt } from "./prompts.js";
+import { buildSupervisorSummary } from "./supervisor-summary.js";
+export class Orchestrator {
+    config;
+    sessions;
+    workers;
+    routeRunner;
+    constructor(config, sessions, workers, routeRunner) {
+        this.config = config;
+        this.sessions = sessions;
+        this.workers = workers;
+        this.routeRunner = routeRunner;
+    }
+    async handleRequest(input) {
+        const route = await routeRequestWithCodex(input.request, this.config, this.routeRunner, input.cwd);
+        const workers = [];
+        if (route.mode === "simple") {
+            input.onStatus?.({ taskId: "main", main: "running" });
+            const output = await this.runMain(input, workers);
+            input.onStatus?.({ taskId: "main", main: "done" });
+            return {
+                mode: "simple",
+                taskId: null,
+                summary: extractMainResponse(output) || emptyMainResponseSummary(),
+                workers
+            };
+        }
+        const task = await this.sessions.createTask({
+            request: input.request,
+            cwd: input.cwd,
+            route
+        });
+        const turn = (await this.sessions.latestTurn(task)) ?? {
+            turnId: "0001",
+            dir: join(task.dir, "turns", "0001"),
+            metaPath: join(task.dir, "turns", "0001", "turn.json"),
+            userPath: join(task.dir, "turns", "0001", "user.md"),
+            routePath: join(task.dir, "turns", "0001", "route.json")
+        };
+        try {
+            await this.sessions.updateTaskStatus(task, "judging");
+            input.onStatus?.({ taskId: task.id, judge: "running", actor: "waiting", critic: "waiting" });
+            const judge = await this.runJudge(input, task, route.judge_engine, workers, turn);
+            const feature = await createFeatureChannel({
+                task,
+                turn,
+                request: input.request,
+                judgeDir: judge.dir
+            });
+            await this.sessions.updateTaskStatus(task, "actor_running");
+            await updateFeatureStatus(feature, "actor_running");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "running", critic: "waiting" });
+            let actor = await this.runActor(input, task, route.actor_engine, judge.dir, workers, turn, feature);
+            await this.sessions.updateTaskStatus(task, "critic_running");
+            await updateFeatureStatus(feature, "critic_running");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "running" });
+            let critic = await this.runCritic(input, task, route.critic_engine, judge.dir, actor.dir, workers, turn, feature);
+            const review = await readTextIfExists(`${critic.dir}/review.md`);
+            if (review.includes("REVISION_REQUIRED")) {
+                await this.sessions.updateTaskStatus(task, "revision_needed");
+                await updateFeatureStatus(feature, "revision_needed");
+                await appendFeatureDialogue(feature, "critic.revision_requested", "critic", "Critic requested Actor revision.", {
+                    review: join(critic.dir, "review.md"),
+                    findings: feature.criticFindingsPath
+                });
+                input.onStatus?.({ taskId: task.id, judge: "done", actor: "revision", critic: "done" });
+                actor = await this.runActor(input, task, route.actor_engine, judge.dir, workers, turn, feature, buildRevisionRequest(review, feature));
+                await this.sessions.updateTaskStatus(task, "critic_running");
+                await updateFeatureStatus(feature, "critic_running");
+                input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "rerunning" });
+                critic = await this.runCritic(input, task, route.critic_engine, judge.dir, actor.dir, workers, turn, feature);
+            }
+            await this.sessions.updateTaskStatus(task, "done");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "done" });
+            const summary = await buildSupervisorSummary({
+                judgeDir: judge.dir,
+                actorDir: actor.dir,
+                criticDir: critic.dir,
+                turnDir: turn.dir,
+                featureActorWorklogPath: feature.actorWorklogPath,
+                featureCriticFindingsPath: feature.criticFindingsPath
+            });
+            await writeText(join(turn.dir, "supervisor-summary.md"), `${summary}\n`);
+            await writeFeatureDecision(feature, summary);
+            await updateFeatureStatus(feature, "approved");
+            return {
+                mode: "complex",
+                taskId: task.id,
+                summary,
+                workers
+            };
+        }
+        catch (error) {
+            await this.sessions.updateTaskStatus(task, "failed");
+            throw error;
+        }
+    }
+    async handleTaskTurn(input) {
+        const task = this.sessions.taskFromId(input.taskId);
+        const route = await routeRequestWithCodex(input.request, this.config, this.routeRunner, input.cwd);
+        const turn = await this.sessions.appendTurn(task, {
+            request: input.request,
+            route
+        });
+        const workers = [];
+        const judgeEngine = route.judge_engine;
+        const actorEngine = route.actor_engine;
+        const criticEngine = route.critic_engine;
+        const judge = this.workerFiles(task, `judge-${judgeEngine}`);
+        const feature = await createFeatureChannel({
+            task,
+            turn,
+            request: input.request,
+            judgeDir: judge.dir
+        });
+        try {
+            await this.sessions.updateTaskStatus(task, "actor_running");
+            await updateFeatureStatus(feature, "actor_running");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "running", critic: "waiting" });
+            let actor = await this.runActor(input, task, actorEngine, judge.dir, workers, turn, feature);
+            await this.sessions.updateTaskStatus(task, "critic_running");
+            await updateFeatureStatus(feature, "critic_running");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "running" });
+            let critic = await this.runCritic(input, task, criticEngine, judge.dir, actor.dir, workers, turn, feature);
+            const review = await readTextIfExists(`${critic.dir}/review.md`);
+            if (review.includes("REVISION_REQUIRED")) {
+                await this.sessions.updateTaskStatus(task, "revision_needed");
+                await updateFeatureStatus(feature, "revision_needed");
+                await appendFeatureDialogue(feature, "critic.revision_requested", "critic", "Critic requested Actor revision.", {
+                    review: join(critic.dir, "review.md"),
+                    findings: feature.criticFindingsPath
+                });
+                input.onStatus?.({ taskId: task.id, judge: "done", actor: "revision", critic: "done" });
+                actor = await this.runActor(input, task, actorEngine, judge.dir, workers, turn, feature, buildRevisionRequest(review, feature));
+                await this.sessions.updateTaskStatus(task, "critic_running");
+                await updateFeatureStatus(feature, "critic_running");
+                input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "rerunning" });
+                critic = await this.runCritic(input, task, criticEngine, judge.dir, actor.dir, workers, turn, feature);
+            }
+            await this.sessions.updateTaskStatus(task, "done");
+            input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "done" });
+            const summary = await buildSupervisorSummary({
+                judgeDir: judge.dir,
+                actorDir: actor.dir,
+                criticDir: critic.dir,
+                turnDir: turn.dir,
+                featureActorWorklogPath: feature.actorWorklogPath,
+                featureCriticFindingsPath: feature.criticFindingsPath
+            });
+            await writeText(join(turn.dir, "supervisor-summary.md"), `${summary}\n`);
+            await writeFeatureDecision(feature, summary);
+            await updateFeatureStatus(feature, "approved");
+            return {
+                mode: "complex",
+                taskId: task.id,
+                summary,
+                workers
+            };
+        }
+        catch (error) {
+            await this.sessions.updateTaskStatus(task, "failed");
+            throw error;
+        }
+    }
+    async routeTaskFollowUp(input) {
+        const task = this.sessions.taskFromId(input.taskId);
+        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
+        const route = await routeRequestWithCodex([
+            "Active task follow-up routing.",
+            `Task id: ${input.taskId}`,
+            `Task status: ${meta?.status ?? "unknown"}`,
+            "",
+            "Choose simple for status/log/reason/explanation questions that can be answered from session files.",
+            "Choose complex for requests that change direction, ask for code changes, reruns, fixes, new experiments, or implementation work.",
+            "",
+            "Follow-up request:",
+            input.request
+        ].join("\n"), this.config, this.routeRunner, input.cwd);
+        return {
+            mode: route.mode,
+            taskId: route.mode === "complex" ? input.taskId : null,
+            reason: route.reason
+        };
+    }
+    async answerTaskQuestion(input) {
+        const task = this.sessions.taskFromId(input.taskId);
+        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
+        const workerSummaries = await Promise.all(["judge", "actor", "critic"].map((role) => this.readLatestWorkerQuestionSummary(task, role)));
+        const workers = workerSummaries.filter((worker) => worker !== null);
+        const failed = workers.find((worker) => worker.status.state === "failed");
+        const latest = failed ?? workers.at(-1);
+        const lines = [
+            `Task ${task.id}${meta ? ` is ${meta.status}` : ""}.`,
+            latest
+                ? `${labelWorker(latest.status)}: ${latest.status.state}/${latest.status.phase}: ${latest.status.summary}`
+                : "No worker status files found for this task."
+        ];
+        if (latest?.logTail) {
+            lines.push("", "Latest worker log:", latest.logTail);
+        }
+        return {
+            mode: "simple",
+            taskId: task.id,
+            summary: lines.join("\n"),
+            workers: []
+        };
+    }
+    async listTaskWorkers(taskId) {
+        const task = this.sessions.taskFromId(taskId);
+        if (!(await pathExists(task.dir))) {
+            return [];
+        }
+        const entries = await readdir(task.dir, { withFileTypes: true });
+        const workers = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const dir = join(task.dir, entry.name);
+            const statusPath = join(dir, "status.json");
+            if (!(await pathExists(statusPath))) {
+                continue;
+            }
+            const status = await readJson(statusPath, WorkerStatusSchema);
+            workers.push({
+                id: status.worker_id,
+                role: status.role,
+                engine: status.engine,
+                label: `${capitalize(status.role)} (${status.engine})`,
+                logPath: join(dir, "output.log"),
+                statusPath
+            });
+        }
+        return workers.sort((left, right) => workerRoleOrder(left.role) - workerRoleOrder(right.role));
+    }
+    async runMain(input, workers) {
+        const engine = this.config.pairing.main;
+        const dir = this.sessions.mainSessionDir();
+        const workerId = `main-${engine}`;
+        const filesDir = join(dir, workerId);
+        const promptPath = join(filesDir, "prompt.md");
+        const outputLogPath = join(filesDir, "output.log");
+        const statusPath = join(filesDir, "status.json");
+        await ensureDir(filesDir);
+        await writeText(promptPath, input.request);
+        await writeText(outputLogPath, "");
+        await writeJson(statusPath, {
+            worker_id: workerId,
+            role: "main",
+            engine,
+            state: "idle",
+            phase: "initialized",
+            last_event_at: new Date().toISOString(),
+            summary: "Main chat worker initialized"
+        });
+        this.recordWorker(input, workers, {
+            id: workerId,
+            role: "main",
+            engine,
+            label: `Main (${engine})`,
+            logPath: outputLogPath,
+            statusPath
+        });
+        await getAdapter(this.workers, engine).run({
+            workerId,
+            role: "main",
+            engine,
+            cwd: input.cwd,
+            filesDir,
+            promptPath,
+            outputLogPath,
+            statusPath,
+            prompt: input.request
+        });
+        return readTextIfExists(outputLogPath);
+    }
+    async runJudge(input, task, engine, workers, turn) {
+        const workerId = `judge-${engine}`;
+        const judgeFiles = this.workerFiles(task, workerId);
+        const judge = await this.sessions.initializeWorker(task, {
+            workerId,
+            role: "judge",
+            engine,
+            prompt: buildJudgePrompt({
+                request: input.request,
+                taskDir: task.dir,
+                workerDir: judgeFiles.dir,
+                turn: this.promptTurnContext(turn),
+                role: this.config.roles.judge
+            })
+        });
+        this.recordWorker(input, workers, {
+            id: judge.workerId,
+            role: "judge",
+            engine,
+            label: `Judge (${engine})`,
+            logPath: judge.outputLogPath,
+            statusPath: judge.statusPath
+        });
+        const result = await this.runWorkerWithNativeSession(engine, {
+            workerId: judge.workerId,
+            role: "judge",
+            engine,
+            cwd: input.cwd,
+            filesDir: judge.dir,
+            promptPath: judge.promptPath,
+            outputLogPath: judge.outputLogPath,
+            statusPath: judge.statusPath,
+            prompt: await readTextIfExists(judge.promptPath)
+        });
+        ensureWorkerSuccess(result.workerId, result.exitCode);
+        return judge;
+    }
+    async runActor(input, task, engine, judgeDir, workers, turn, feature, revision) {
+        const actor = await this.sessions.initializeWorker(task, {
+            workerId: `actor-${engine}`,
+            role: "actor",
+            engine,
+            prompt: buildActorPrompt({
+                request: input.request,
+                taskDir: task.dir,
+                judgeDir,
+                turn: this.promptTurnContext(turn),
+                feature: featurePromptContext(feature),
+                revision,
+                role: this.config.roles.actor
+            })
+        });
+        this.recordWorker(input, workers, {
+            id: actor.workerId,
+            role: "actor",
+            engine,
+            label: `Actor (${engine})`,
+            logPath: actor.outputLogPath,
+            statusPath: actor.statusPath
+        });
+        const result = await this.runWorkerWithNativeSession(engine, {
+            workerId: actor.workerId,
+            role: "actor",
+            engine,
+            cwd: input.cwd,
+            filesDir: actor.dir,
+            promptPath: actor.promptPath,
+            outputLogPath: actor.outputLogPath,
+            statusPath: actor.statusPath,
+            prompt: await readTextIfExists(actor.promptPath)
+        });
+        ensureWorkerSuccess(result.workerId, result.exitCode);
+        await mirrorWorkerFileToFeature(join(actor.dir, "worklog.md"), feature.actorWorklogPath);
+        await appendFeatureDialogue(feature, "actor.completed", "actor", "Actor completed feature work.", {
+            worklog: actor.outputLogPath,
+            feature_worklog: feature.actorWorklogPath,
+            replies: feature.actorRepliesPath
+        });
+        return actor;
+    }
+    async runCritic(input, task, engine, judgeDir, actorDir, workers, turn, feature) {
+        const critic = await this.sessions.initializeWorker(task, {
+            workerId: `critic-${engine}`,
+            role: "critic",
+            engine,
+            prompt: buildCriticPrompt({
+                request: input.request,
+                taskDir: task.dir,
+                judgeDir,
+                actorDir,
+                turn: this.promptTurnContext(turn),
+                feature: featurePromptContext(feature),
+                role: this.config.roles.critic
+            })
+        });
+        this.recordWorker(input, workers, {
+            id: critic.workerId,
+            role: "critic",
+            engine,
+            label: `Critic (${engine})`,
+            logPath: critic.outputLogPath,
+            statusPath: critic.statusPath
+        });
+        const result = await this.runWorkerWithNativeSession(engine, {
+            workerId: critic.workerId,
+            role: "critic",
+            engine,
+            cwd: input.cwd,
+            filesDir: critic.dir,
+            promptPath: critic.promptPath,
+            outputLogPath: critic.outputLogPath,
+            statusPath: critic.statusPath,
+            prompt: await readTextIfExists(critic.promptPath)
+        });
+        ensureWorkerSuccess(result.workerId, result.exitCode);
+        await appendFeatureDialogue(feature, "critic.completed", "critic", "Critic completed feature review.", {
+            review: join(critic.dir, "review.md"),
+            findings: feature.criticFindingsPath
+        });
+        return critic;
+    }
+    recordWorker(input, workers, worker) {
+        const existingIndex = workers.findIndex((item) => item.id === worker.id);
+        if (existingIndex >= 0) {
+            workers[existingIndex] = worker;
+        }
+        else {
+            workers.push(worker);
+        }
+        input.onWorker?.(worker);
+    }
+    async runWorkerWithNativeSession(engine, spec) {
+        const adapter = getAdapter(this.workers, engine);
+        const workerFiles = {
+            workerId: spec.workerId,
+            dir: spec.filesDir,
+            promptPath: spec.promptPath,
+            outputLogPath: spec.outputLogPath,
+            statusPath: spec.statusPath
+        };
+        const existing = await this.sessions.readNativeSession(workerFiles);
+        if (existing) {
+            await this.sessions.writeNativeSession(workerFiles, {
+                ...existing,
+                last_used_at: new Date().toISOString()
+            });
+        }
+        return adapter.run({
+            ...spec,
+            nativeSession: existing,
+            nativeSessionConfig: this.config.workers[engine].nativeSession,
+            onNativeSession: async (sessionId) => {
+                const now = new Date().toISOString();
+                const previous = await this.sessions.readNativeSession(workerFiles);
+                const record = {
+                    engine,
+                    role: spec.role,
+                    worker_id: spec.workerId,
+                    session_id: sessionId,
+                    scope: "task",
+                    cwd: spec.cwd,
+                    created_at: previous?.created_at ?? now,
+                    last_used_at: now,
+                    source: previous?.source ?? "output-detected"
+                };
+                await this.sessions.writeNativeSession(workerFiles, record);
+            },
+            onNativeSessionRetired: async (_sessionId, reason) => {
+                await this.sessions.retireNativeSession(workerFiles, summarizeRetirementReason(reason));
+            }
+        });
+    }
+    workerFiles(task, workerId) {
+        const dir = join(task.dir, workerId);
+        return {
+            workerId,
+            dir,
+            promptPath: join(dir, "prompt.md"),
+            outputLogPath: join(dir, "output.log"),
+            statusPath: join(dir, "status.json")
+        };
+    }
+    promptTurnContext(turn) {
+        return {
+            turnId: turn.turnId,
+            turnDir: turn.dir,
+            previousSummaries: []
+        };
+    }
+    async readLatestWorkerQuestionSummary(task, role) {
+        for (const engine of ["codex", "claude", "mock"]) {
+            const files = this.workerFiles(task, `${role}-${engine}`);
+            if (!(await pathExists(files.statusPath))) {
+                continue;
+            }
+            const status = await readJson(files.statusPath, WorkerStatusSchema);
+            return {
+                status,
+                logTail: tailText(await readTextIfExists(files.outputLogPath), 8)
+            };
+        }
+        return null;
+    }
+}
+function ensureWorkerSuccess(workerId, exitCode) {
+    if (exitCode !== 0) {
+        throw new Error(`${workerId} failed with exit code ${exitCode}`);
+    }
+}
+function summarizeRetirementReason(reason) {
+    const lines = reason
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const contextLine = lines.find((line) => /context window|ran out of room|clear earlier history|start a new thread/i.test(line));
+    const summary = contextLine ?? lines.at(-1) ?? "Native session retired";
+    return summary.length > 240 ? `${summary.slice(0, 237)}...` : summary;
+}
+function buildRevisionRequest(review, feature) {
+    return [
+        review.trim(),
+        "",
+        "Feature mailbox:",
+        `- Critic findings: ${feature.criticFindingsPath}`,
+        `- Actor replies: ${feature.actorRepliesPath}`,
+        "Reply to each fixed finding in actor-replies.jsonl."
+    ].join("\n");
+}
+async function mirrorWorkerFileToFeature(sourcePath, targetPath) {
+    const content = await readTextIfExists(sourcePath);
+    if (content.trim()) {
+        await writeText(targetPath, content);
+    }
+}
+function extractMainResponse(outputLog) {
+    return outputLog
+        .split("\n")
+        .filter((line) => !line.startsWith("$ "))
+        .filter((line) => !line.startsWith("[mock:main]"))
+        .join("\n")
+        .trim();
+}
+function emptyMainResponseSummary() {
+    return "简单对话通道没有收到可显示回复。";
+}
+function labelWorker(status) {
+    return `${capitalize(status.role)} (${status.engine})`;
+}
+function capitalize(value) {
+    return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+function workerRoleOrder(role) {
+    return ["main", "judge", "actor", "critic"].indexOf(role);
+}
+function tailText(text, lines) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => line.trim())
+        .slice(-lines)
+        .join("\n")
+        .trim();
+}

package/dist/orchestrator/prompts.js

@@ -0,0 +1,124 @@
+export function buildJudgePrompt(input) {
+    const role = roleConfig(input.role, "Judge", [
+        "You clarify requirements and write task files. Do not implement code."
+    ]);
+    return [
+        `# Role: ${role.title}`,
+        "",
+        ...instructionLines(role.instructions),
+        "",
+        `Task directory: ${input.taskDir}`,
+        ...(input.workerDir ? [`Worker directory: ${input.workerDir}`] : []),
+        ...turnLines(input.turn),
+        "",
+        "Write these files in the worker directory above:",
+        "- requirements.md",
+        "- plan.md",
+        "- acceptance.md",
+        "- actor-brief.md",
+        "- critic-brief.md",
+        "",
+        "User request:",
+        input.request,
+        ""
+    ].join("\n");
+}
+export function buildActorPrompt(input) {
+    const role = roleConfig(input.role, "Actor", [
+        "Read Judge files, implement the requested change, and record your work."
+    ]);
+    return [
+        `# Role: ${role.title}`,
+        "",
+        ...instructionLines(role.instructions),
+        "",
+        `Task directory: ${input.taskDir}`,
+        `Judge directory: ${input.judgeDir}`,
+        ...turnLines(input.turn),
+        ...featureLines(input.feature),
+        "",
+        "Read:",
+        "- requirements.md",
+        "- plan.md",
+        "- acceptance.md",
+        "- actor-brief.md",
+        "",
+        "Write in your worker directory:",
+        "- worklog.md",
+        "- patch.diff when a diff is available",
+        "",
+        "Feature mailbox writes:",
+        "- actor-worklog.md with implementation notes for this feature.",
+        "- actor-replies.jsonl with one JSON object per Critic finding you fixed.",
+        "",
+        input.revision ? `Revision request:\n${input.revision}` : "No Critic revision request is active.",
+        "",
+        "User request:",
+        input.request,
+        ""
+    ].join("\n");
+}
+export function buildCriticPrompt(input) {
+    const role = roleConfig(input.role, "Critic", [
+        "Review Actor work against Judge requirements. Lead with blocking findings."
+    ]);
+    return [
+        `# Role: ${role.title}`,
+        "",
+        ...instructionLines(role.instructions),
+        "",
+        `Task directory: ${input.taskDir}`,
+        `Judge directory: ${input.judgeDir}`,
+        `Actor directory: ${input.actorDir ?? ""}`,
+        ...turnLines(input.turn),
+        ...featureLines(input.feature),
+        "",
+        "Read Judge files and Actor output.",
+        "Read actor-replies.jsonl when reviewing a revision.",
+        "",
+        "Write review.md in your worker directory. Include APPROVED when no blocking findings remain.",
+        "If revision is required, include REVISION_REQUIRED and a concise fix list.",
+        "Write critic-findings.jsonl in the feature mailbox with one JSON object per blocking issue.",
+        "",
+        "User request:",
+        input.request,
+        ""
+    ].join("\n");
+}
+function roleConfig(role, title, instructions) {
+    return {
+        title: role?.title ?? title,
+        instructions: role?.instructions?.length ? role.instructions : instructions
+    };
+}
+function instructionLines(instructions) {
+    if (instructions.length === 1) {
+        return [instructions[0]];
+    }
+    return instructions.map((instruction) => `- ${instruction}`);
+}
+function featureLines(feature) {
+    if (!feature) {
+        return [];
+    }
+    return [
+        `Feature id: ${feature.featureId}`,
+        `Feature directory: ${feature.featureDir}`,
+        `Actor/Critic dialogue log: ${feature.dialoguePath}`,
+        `Actor feature worklog: ${feature.actorWorklogPath}`,
+        `Critic findings: ${feature.criticFindingsPath}`,
+        `Actor replies: ${feature.actorRepliesPath}`,
+        `Feature decisions: ${feature.decisionsPath}`
+    ];
+}
+function turnLines(turn) {
+    if (!turn) {
+        return [];
+    }
+    return [
+        `Current turn: ${turn.turnId}`,
+        `Current turn directory: ${turn.turnDir}`,
+        "Previous turn summaries:",
+        ...(turn.previousSummaries?.length ? turn.previousSummaries.map((summary) => `- ${summary}`) : ["- (none)"])
+    ];
+}