peon-mem 1.0.7 → 1.0.8

package/dist/roundtable.js

@@ -1,787 +0,0 @@
-import { access, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { constants as fsConstants, existsSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { homedir, tmpdir } from "node:os";
-import { basename, isAbsolute, join } from "node:path";
-const MAX_QUESTION_CHARS = 4_000;
-const MAX_AGENT_OUTPUT_CHARS = 20_000;
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1_000;
-const AUTONOMOUS_AGENDA = "Using the current Peon project memory, identify the single most important unresolved problem blocking the project's main objective. Debate the best next move, with special attention to prior failed ideas, available evidence, novelty, measurable impact, and the smallest decisive test. Do not run the test or change anything.";
-export class RoundtableManager {
-    options;
-    runs = new Map();
-    subscribers = new Set();
-    runner;
-    now;
-    queue = Promise.resolve();
-    persistQueue = Promise.resolve();
-    constructor(options) {
-        this.options = options;
-        this.runner = options.runner ?? new LocalSubscriptionRunner();
-        this.now = options.now ?? (() => new Date().toISOString());
-    }
-    async initialize() {
-        await mkdir(this.options.stateDir, { recursive: true });
-        const names = await readdir(this.options.stateDir).catch(() => []);
-        for (const name of names.filter((value) => value.endsWith(".json"))) {
-            try {
-                const parsed = JSON.parse(await readFile(join(this.options.stateDir, name), "utf8"));
-                if (!parsed?.id || !parsed.projectPath || !Array.isArray(parsed.turns))
-                    continue;
-                if (!Array.isArray(parsed.activities))
-                    parsed.activities = [];
-                const interrupted = parsed.status === "queued" || parsed.status === "running";
-                const restartFailure = parsed.status === "failed" && parsed.error === "Peon restarted before this discussion finished. Start a new roundtable to continue.";
-                if (interrupted || restartFailure) {
-                    parsed.status = "open";
-                    parsed.stage = "complete";
-                    delete parsed.error;
-                    parsed.updatedAt = this.now();
-                    await this.persist(parsed);
-                }
-                this.runs.set(parsed.id, parsed);
-            }
-            catch {
-                // One damaged history file must not prevent the daemon from starting.
-            }
-        }
-    }
-    availability() {
-        return this.runner.availability();
-    }
-    list(projectPath) {
-        return [...this.runs.values()]
-            .filter((run) => !projectPath || run.projectPath === projectPath)
-            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    }
-    get(id) {
-        return this.runs.get(id);
-    }
-    subscribe(listener) {
-        this.subscribers.add(listener);
-        return () => this.subscribers.delete(listener);
-    }
-    async start(projectPath, rawQuestion) {
-        if (!isAbsolute(projectPath))
-            throw new Error("projectPath must be absolute");
-        if (rawQuestion !== undefined && typeof rawQuestion !== "string") {
-            throw new Error("question must be a string");
-        }
-        const supplied = rawQuestion?.trim() ?? "";
-        const question = supplied || AUTONOMOUS_AGENDA;
-        if (question.length > MAX_QUESTION_CHARS)
-            throw new Error(`question must be at most ${MAX_QUESTION_CHARS} characters`);
-        const createdAt = this.now();
-        const run = {
-            id: crypto.randomUUID(),
-            projectPath,
-            question,
-            mode: supplied ? "focused" : "autonomous",
-            status: "queued",
-            stage: "queued",
-            createdAt,
-            updatedAt: createdAt,
-            turns: [],
-            activities: []
-        };
-        this.runs.set(run.id, run);
-        await this.persist(run);
-        this.emit(run);
-        // One discussion at a time keeps subscription usage predictable and prevents
-        // several local agent processes from competing for the same project.
-        this.queue = this.queue.then(() => this.execute(run.id), () => this.execute(run.id));
-        return run;
-    }
-    async approve(id) {
-        const run = this.runs.get(id);
-        if (!run)
-            throw new Error("Roundtable discussion not found");
-        if (run.status !== "awaiting_approval")
-            throw new Error("This proposal is not waiting for approval");
-        const recommendation = latestRecommendation(run);
-        if (!recommendation)
-            throw new Error("This proposal has no final recommendation");
-        await this.options.memory.saveDecision(run.projectPath, run.question, recommendation);
-        run.status = "executing";
-        run.stage = "implementation";
-        run.approvedAt = this.now();
-        await this.touch(run);
-        this.queue = this.queue.then(() => this.executeApproved(run.id), () => this.executeApproved(run.id));
-        return run;
-    }
-    async message(id, rawMessage) {
-        const run = this.runs.get(id);
-        if (!run)
-            throw new Error("Roundtable discussion not found");
-        const startsFollowUp = run.status === "open" ||
-            run.status === "awaiting_approval" ||
-            run.status === "complete" ||
-            run.status === "rejected" ||
-            run.status === "failed";
-        if (!startsFollowUp) {
-            throw new Error("Wait for the current room step to finish before sending a message");
-        }
-        if (typeof rawMessage !== "string")
-            throw new Error("message must be a string");
-        const message = rawMessage.trim();
-        if (!message)
-            throw new Error("message is required");
-        if (message.length > MAX_QUESTION_CHARS) {
-            throw new Error(`message must be at most ${MAX_QUESTION_CHARS} characters`);
-        }
-        run.turns.push(makeTurn("user", "discussion", message, this.now()));
-        run.status = "running";
-        run.stage = "discussion";
-        await this.touch(run);
-        const next = isCasualGreeting(message)
-            ? () => this.executeCasualReply(run.id, message)
-            : () => this.executeRevision(run.id);
-        this.queue = this.queue.then(next, next);
-        return run;
-    }
-    async propose(id) {
-        const run = this.runs.get(id);
-        if (!run)
-            throw new Error("Roundtable discussion not found");
-        if (run.status !== "open")
-            throw new Error("Wait until the room is open before asking for an agreed action");
-        run.status = "running";
-        run.stage = "synthesis";
-        await this.touch(run);
-        this.queue = this.queue.then(() => this.executeProposal(run.id), () => this.executeProposal(run.id));
-        return run;
-    }
-    async continueDiscussion(id) {
-        const run = this.runs.get(id);
-        if (!run)
-            throw new Error("Roundtable discussion not found");
-        if (run.status !== "open")
-            throw new Error("The room must be open before continuing the discussion");
-        run.status = "running";
-        run.stage = "discussion";
-        await this.touch(run);
-        this.queue = this.queue.then(() => this.executeRevision(run.id), () => this.executeRevision(run.id));
-        return run;
-    }
-    async reject(id) {
-        const run = this.runs.get(id);
-        if (!run)
-            throw new Error("Roundtable discussion not found");
-        if (run.status !== "awaiting_approval")
-            throw new Error("This proposal is not waiting for approval");
-        run.status = "rejected";
-        run.stage = "complete";
-        await this.touch(run);
-        return run;
-    }
-    async execute(id) {
-        const run = this.runs.get(id);
-        if (!run)
-            return;
-        try {
-            const available = await this.runner.availability();
-            const missing = ["codex", "claude"].filter((agent) => !available[agent].available);
-            if (missing.length)
-                throw new Error(`Unavailable local client: ${missing.join(" and ")}`);
-            run.status = "running";
-            run.stage = "discussion";
-            await this.touch(run);
-            const context = await this.options.memory.getContext({
-                projectPath: run.projectPath,
-                query: run.question,
-                maxChars: 7_000
-            });
-            const sharedBrief = buildSharedBrief(run.question, context);
-            const addRoomTurn = async (agent, prompt) => {
-                const output = await this.runner.run(agent, prompt, run.projectPath);
-                run.turns.push(makeTurn(agent, "discussion", output, this.now()));
-                await this.touch(run);
-                return output;
-            };
-            await addRoomTurn("codex", roomOpeningPrompt(sharedBrief));
-            await addRoomTurn("claude", roomReplyPrompt("Claude", sharedBrief, run.turns, "Respond directly to Codex. Challenge weak evidence, add missing context, and suggest a stronger shared direction."));
-            await addRoomTurn("codex", roomReplyPrompt("Codex", sharedBrief, run.turns, "Answer Claude's challenges directly. Revise or defend the design, and narrow it to a decisive experiment."));
-            const latest = await addRoomTurn("claude", roomReplyPrompt("Claude", sharedBrief, run.turns, "Test Codex's revised direction against the evidence. State a concrete disagreement or unresolved risk when one exists; otherwise explain exactly what evidence earns agreement."));
-            run.liveSummary = firstSentence(latest);
-            run.status = "open";
-            run.stage = "complete";
-            await this.touch(run);
-        }
-        catch (error) {
-            run.status = "failed";
-            run.stage = "failed";
-            run.error = safeError(error);
-            await this.touch(run);
-        }
-    }
-    async executeApproved(id) {
-        const run = this.runs.get(id);
-        if (!run || run.status !== "executing")
-            return;
-        try {
-            const recommendation = latestRecommendation(run);
-            if (!recommendation)
-                throw new Error("Approved proposal has no recommendation to implement");
-            const context = await this.options.memory.getContext({
-                projectPath: run.projectPath,
-                query: run.question,
-                maxChars: 7_000
-            });
-            const sharedBrief = buildSharedBrief(run.question, context);
-            run.stage = "implementation";
-            const collaboratorActivity = await this.startActivity(run, "claude", "review", "Claude is defining independent checks for the approved work");
-            const collaboratorPlan = await this.runner.run("claude", collaborationImplementationPrompt(sharedBrief, recommendation), run.projectPath, "review");
-            run.turns.push(makeTurn("claude", "implementation", collaboratorPlan, this.now()));
-            await this.finishActivity(run, collaboratorActivity, "passed", collaboratorPlan);
-            const implementationActivity = await this.startActivity(run, "codex", "code", "Codex is implementing the approved work");
-            const changesBeforeImplementation = await collectWorkspaceChanges(run.projectPath);
-            const implementation = await this.runner.run("codex", implementationPrompt(sharedBrief, recommendation, collaboratorPlan), run.projectPath, "implement");
-            run.turns.push(makeTurn("codex", "implementation", implementation, this.now()));
-            await this.finishActivity(run, implementationActivity, "passed", implementation);
-            const changesAfterImplementation = await collectWorkspaceChanges(run.projectPath);
-            const implementationChanges = changedWorkspaceSnapshot(changesBeforeImplementation, changesAfterImplementation);
-            if (implementationChanges.length) {
-                await this.addActivity(run, {
-                    agent: "codex",
-                    type: "artifact",
-                    title: `${implementationChanges.length} workspace ${implementationChanges.length === 1 ? "change" : "changes"} visible after implementation`,
-                    detail: implementationChanges.join("\n"),
-                    state: "info"
-                });
-            }
-            run.stage = "review";
-            const reviewActivity = await this.startActivity(run, "claude", "review", "Claude is independently checking the implementation");
-            const review = await this.runner.run("claude", reviewPrompt(sharedBrief, recommendation, implementation), run.projectPath, "review");
-            run.turns.push(makeTurn("claude", "review", review, this.now()));
-            await this.finishActivity(run, reviewActivity, "passed", review);
-            run.stage = "verification";
-            const verificationActivity = await this.startActivity(run, "codex", "test", "Codex is addressing findings and running verification");
-            const verification = await this.runner.run("codex", verificationPrompt(sharedBrief, recommendation, implementation, review), run.projectPath, "verify");
-            run.turns.push(makeTurn("codex", "verification", verification, this.now()));
-            await this.finishActivity(run, verificationActivity, reportFailed(verification) ? "failed" : "passed", verification);
-            await this.options.memory.saveResult(run.projectPath, run.question, verification);
-            await this.addActivity(run, {
-                agent: "room",
-                type: "result",
-                title: "Local work finished",
-                detail: firstSentence(verification),
-                state: reportFailed(verification) ? "failed" : "passed"
-            });
-            run.status = "complete";
-            run.stage = "complete";
-            await this.touch(run);
-        }
-        catch (error) {
-            await this.failRunningActivities(run, safeError(error));
-            run.status = "failed";
-            run.stage = "failed";
-            run.error = safeError(error);
-            await this.touch(run);
-        }
-    }
-    async startActivity(run, agent, type, title) {
-        return this.addActivity(run, { agent, type, title, state: "running" });
-    }
-    async addActivity(run, input) {
-        const createdAt = this.now();
-        const activity = {
-            id: crypto.randomUUID(),
-            agent: input.agent,
-            type: input.type,
-            title: input.title,
-            detail: input.detail?.trim().slice(0, MAX_AGENT_OUTPUT_CHARS),
-            state: input.state,
-            createdAt,
-            updatedAt: createdAt
-        };
-        (run.activities ??= []).push(activity);
-        await this.touch(run);
-        return activity.id;
-    }
-    async finishActivity(run, id, state, detail) {
-        const activity = (run.activities ?? []).find((item) => item.id === id);
-        if (!activity)
-            return;
-        activity.state = state;
-        activity.detail = detail?.trim().slice(0, MAX_AGENT_OUTPUT_CHARS);
-        activity.updatedAt = this.now();
-        await this.touch(run);
-    }
-    async failRunningActivities(run, detail) {
-        let changed = false;
-        for (const activity of run.activities ?? []) {
-            if (activity.state !== "running")
-                continue;
-            activity.state = "failed";
-            activity.detail = detail;
-            activity.updatedAt = this.now();
-            changed = true;
-        }
-        if (changed)
-            await this.touch(run);
-    }
-    async concludeAgreement(run, sharedBrief, jointDraft) {
-        run.stage = "synthesis";
-        await this.touch(run);
-        const confirmation = await this.runner.run("codex", agreementPrompt(sharedBrief, run.turns), run.projectPath);
-        run.turns.push(makeTurn("codex", "discussion", confirmation, this.now()));
-        if (/^AGREED\b/i.test(confirmation.trim())) {
-            const jointProposal = `${jointDraft.trim()}\n\nAgreement check\n- Claude prepared the shared draft after the discussion.\n- Codex confirmed: ${confirmation.trim()}`;
-            run.turns.push(makeTurn("joint", "recommendation", jointProposal, this.now()));
-            await this.options.memory.saveProposal(run.projectPath, run.question, jointProposal);
-            run.status = "awaiting_approval";
-            run.liveSummary = "Codex and Claude have an agreed action ready for your review.";
-        }
-        else {
-            run.status = "open";
-        }
-        run.stage = "complete";
-        await this.touch(run);
-    }
-    async executeRevision(id) {
-        const run = this.runs.get(id);
-        if (!run || run.status !== "running")
-            return;
-        try {
-            const context = await this.options.memory.getContext({
-                projectPath: run.projectPath,
-                query: run.question,
-                maxChars: 7_000
-            });
-            const sharedBrief = buildSharedBrief(run.question, context);
-            const latestAgent = [...run.turns].reverse().find((turn) => turn.agent === "codex" || turn.agent === "claude")?.agent;
-            let agent = latestAgent === "claude" ? "codex" : "claude";
-            let settledInARow = 0;
-            for (let turn = 0; turn < 8; turn += 1) {
-                const instruction = turn === 0
-                    ? "Respond naturally to the user's newest message. Answer it directly and begin a useful discussion with the other agent."
-                    : "Reply directly to the other agent's latest point. Challenge it or add useful evidence when needed; do not repeat points already made.";
-                const raw = await this.runner.run(agent, debateReplyPrompt(agent === "codex" ? "Codex" : "Claude", sharedBrief, run.turns, instruction), run.projectPath);
-                const parsed = parseDebateReply(raw);
-                run.turns.push(makeTurn(agent, "discussion", parsed.content, this.now()));
-                if (parsed.summary)
-                    run.liveSummary = parsed.summary;
-                await this.touch(run);
-                settledInARow = parsed.settled ? settledInARow + 1 : 0;
-                if (settledInARow >= 2)
-                    break;
-                agent = agent === "claude" ? "codex" : "claude";
-            }
-            run.status = "open";
-            run.stage = "complete";
-            await this.touch(run);
-        }
-        catch (error) {
-            run.status = "failed";
-            run.stage = "failed";
-            run.error = safeError(error);
-            await this.touch(run);
-        }
-    }
-    async executeCasualReply(id, message) {
-        const run = this.runs.get(id);
-        if (!run || run.status !== "running")
-            return;
-        try {
-            const reply = async (agent) => {
-                const output = await this.runner.run(agent, casualReplyPrompt(agent, message), run.projectPath, "chat");
-                run.turns.push(makeTurn(agent, "discussion", output, this.now()));
-                await this.touch(run);
-            };
-            await Promise.all([reply("codex"), reply("claude")]);
-            run.status = "open";
-            run.stage = "complete";
-            await this.touch(run);
-        }
-        catch (error) {
-            run.status = "failed";
-            run.stage = "failed";
-            run.error = safeError(error);
-            await this.touch(run);
-        }
-    }
-    async executeProposal(id) {
-        const run = this.runs.get(id);
-        if (!run || run.status !== "running" || run.stage !== "synthesis")
-            return;
-        try {
-            const context = await this.options.memory.getContext({
-                projectPath: run.projectPath,
-                query: run.question,
-                maxChars: 7_000
-            });
-            const sharedBrief = buildSharedBrief(run.question, context);
-            const jointDraft = await this.runner.run("claude", roomReplyPrompt("Claude", sharedBrief, run.turns, "The user explicitly asked the room to form an agreed action. Draft the smallest concrete action supported by the conversation. Preserve any disagreement instead of hiding it."), run.projectPath);
-            run.turns.push(makeTurn("claude", "discussion", jointDraft, this.now()));
-            await this.touch(run);
-            await this.concludeAgreement(run, sharedBrief, jointDraft);
-        }
-        catch (error) {
-            run.status = "failed";
-            run.stage = "failed";
-            run.error = safeError(error);
-            await this.touch(run);
-        }
-    }
-    async touch(run) {
-        run.updatedAt = this.now();
-        await this.persist(run);
-        this.emit(run);
-    }
-    emit(run) {
-        for (const listener of this.subscribers) {
-            try {
-                listener(run);
-            }
-            catch {
-                // A disconnected monitor must never interrupt the research workflow.
-            }
-        }
-    }
-    async persist(run) {
-        // Snapshot now, then serialize writes. Approval can arrive immediately after
-        // synthesis and would otherwise race the final proposal persist on the same
-        // `.tmp` path, occasionally losing or renaming the other writer's file.
-        const content = `${JSON.stringify(run, null, 2)}\n`;
-        const path = join(this.options.stateDir, `${run.id}.json`);
-        const task = this.persistQueue.then(async () => {
-            await mkdir(this.options.stateDir, { recursive: true });
-            const tempPath = `${path}.${crypto.randomUUID()}.tmp`;
-            await writeFile(tempPath, content, "utf8");
-            await rename(tempPath, path);
-        });
-        this.persistQueue = task.catch(() => undefined);
-        await task;
-    }
-}
-export class LocalSubscriptionRunner {
-    async availability() {
-        const [codex, claude] = await Promise.all([resolveCodexBinary(), resolveClaudeBinary()]);
-        const [codexAuthenticated, claudeAuthenticated] = await Promise.all([
-            codex ? isCodexAuthenticated(codex) : Promise.resolve(false),
-            claude ? isClaudeAuthenticated(claude) : Promise.resolve(false)
-        ]);
-        return {
-            codex: {
-                available: Boolean(codex && codexAuthenticated),
-                label: !codex ? "Codex client not found" : codexAuthenticated ? "Codex via ChatGPT login" : "Codex login required"
-            },
-            claude: {
-                available: Boolean(claude && claudeAuthenticated),
-                label: !claude ? "Claude client not found" : claudeAuthenticated ? "Claude Code via Claude login" : "Claude login required"
-            }
-        };
-    }
-    async run(agent, prompt, projectPath, mode = "research") {
-        if (agent === "codex")
-            return runCodex(prompt, projectPath, mode);
-        return runClaude(prompt, projectPath, mode);
-    }
-}
-function makeTurn(agent, kind, raw, createdAt) {
-    const content = raw.trim().slice(0, MAX_AGENT_OUTPUT_CHARS);
-    if (!content)
-        throw new Error(`${agent} returned an empty response`);
-    return { id: crypto.randomUUID(), agent, kind, content, createdAt };
-}
-function latestRecommendation(run) {
-    return [...run.turns].reverse().find((turn) => turn.kind === "recommendation")?.content;
-}
-function isCasualGreeting(message) {
-    const normalized = message.toLowerCase().replace(/[^a-z\s']/g, " ").replace(/\s+/g, " ").trim();
-    return /^(hi|hello|hey|hiya|good morning|good afternoon|good evening|how are you|what's up|whats up)( everyone| both| guys| codex| claude| there)?$/.test(normalized);
-}
-function casualReplyPrompt(agent, message) {
-    return `You are ${agent === "codex" ? "Codex" : "Claude"} in a three-person thesis room with the user and the other agent. The user said: ${JSON.stringify(message)}. Reply like a normal friendly teammate in no more than two short sentences. This is casual conversation: do not analyze the thesis, load project context, use tools, propose work, or make a decision.`;
-}
-function buildSharedBrief(question, context) {
-    const sections = [
-        ["Project summary", context.summary],
-        ["Relevant memory", context.memories],
-        ["Prior decisions", context.decisions],
-        ["Preferences", context.preferences],
-        ["Open questions", context.openQuestions],
-        ["Artifacts", context.artifacts]
-    ]
-        .filter((entry) => entry[1]?.trim())
-        .map((entry) => `## ${entry[0]}\n${entry[1]}`)
-        .join("\n\n");
-    return `# Question\n${question}\n\n# Communication style\nSpeak as a helpful thesis teammate, not as a paper or technical report. Use plain everyday language and keep the whole message under 220 words. Start with the practical meaning for the thesis. Do not show an evidence ledger, table, long numbered list, or dense technical detail. Avoid jargon and unexplained acronyms. If a technical term is unavoidable, explain it with a one-sentence example. For a proposed action, use only these short labels: What, Why, How, Success, Stop.\n\n# Repository isolation\nIf an isolated \`workspace/\` directory exists, treat it as the repository root for every inspection, edit, and test. The parent project directory is the copied Peon memory container and must not be treated as the source checkout.\n\n# Shared Peon context\n${sections || "No relevant project memory was found."}`;
-}
-function roomOpeningPrompt(sharedBrief) {
-    return `${sharedBrief}\n\n# Shared-room opening\nYou are Codex, the first speaker in a live research room with Claude. Privately check the project's objective, supervisor constraints, reliable baseline, completed and failed experiments, current work, blockers, and relevant research. Search the copied Peon files and isolated repository only when the summary is insufficient. Do not print that audit or a technical report. In the room, say only the most important unresolved problem, why it matters in simple words, and one concrete question or tentative direction for Claude. Do not present a final proposal yet. Use read-only inspection and primary sources when useful. Do not modify files, submit jobs, contact anyone, or reveal private chain-of-thought.`;
-}
-function formatRoomTranscript(turns) {
-    return turns.map((turn) => `## ${turn.agent}\n${turn.content}`).join("\n\n");
-}
-function roomReplyPrompt(name, sharedBrief, turns, instruction) {
-    return `${sharedBrief}\n\n# Live room transcript\n${formatRoomTranscript(turns)}\n\n# Your next room message\nYou are ${name}, an equal research partner in this room. ${instruction} Respond to the newest room messages, including any message from the user, and speak to the other agent directly. Build on the transcript rather than restarting the analysis. Do not agree merely to be cooperative: test the strongest assumption, identify contrary evidence, and say clearly when the evidence is insufficient. If you agree, name the concrete evidence that earns agreement and any uncertainty that remains. Cite concrete evidence when it changes the decision. Keep the discussion focused on the thesis objective and a publishable, measurable next direction. Do not modify files, submit jobs, contact anyone, invent results, or reveal private chain-of-thought.`;
-}
-function debateReplyPrompt(name, sharedBrief, turns, instruction) {
-    return `${roomReplyPrompt(name, sharedBrief, turns, instruction)}\n\n# Natural stopping signal\nAfter your visible reply, add exactly one plain sentence summarizing where the debate now stands inside [[ROOM_SUMMARY: ...]]. Then end with exactly [[ROOM:CONTINUE]] when there is still a useful disagreement, unanswered question, or new evidence for the other agent to address. End with exactly [[ROOM:SETTLED]] only when you have no useful correction or addition left. Both markers are hidden from the user. Never create a proposal merely because the discussion is settled.`;
-}
-function parseDebateReply(raw) {
-    const trimmed = raw.trim();
-    const full = trimmed.match(/\[\[ROOM_SUMMARY:\s*([\s\S]*?)\]\]\s*\[\[ROOM:(CONTINUE|SETTLED)\]\]\s*$/i);
-    if (full) {
-        return {
-            content: trimmed.slice(0, full.index).trim(),
-            settled: full[2].toUpperCase() === "SETTLED",
-            summary: full[1].replace(/\s+/g, " ").trim().slice(0, 280)
-        };
-    }
-    const marker = trimmed.match(/\[\[ROOM:(CONTINUE|SETTLED)\]\]\s*$/i);
-    return {
-        content: marker ? trimmed.slice(0, marker.index).trim() : trimmed,
-        settled: marker?.[1].toUpperCase() === "SETTLED"
-    };
-}
-function firstSentence(value) {
-    const plain = value.replace(/[#>*_`|\[\]()]/g, " ").replace(/\s+/g, " ").trim();
-    const sentence = plain.match(/^.{1,280}?(?:[.!?](?:\s|$)|$)/)?.[0] ?? plain.slice(0, 280);
-    return sentence.trim().slice(0, 280);
-}
-function agreementPrompt(sharedBrief, turns) {
-    return `${sharedBrief}\n\n# Complete live room transcript\n${formatRoomTranscript(turns)}\n\n# Agreement check\nYou are Codex, still speaking inside the same room. Check whether Claude's newest joint draft honestly reflects the evidence and the points both agents reached together. Start your answer with exactly AGREED if you accept the draft as the shared next action, or CHANGES NEEDED if you do not. Then explain the reason briefly in plain language. Do not rewrite or synthesize the draft, modify anything, or pretend agreement.`;
-}
-function collaborationImplementationPrompt(sharedBrief, recommendation) {
-    return `${sharedBrief}\n\n# User-approved proposal\n${recommendation}\n\n# Equal-partner implementation check\nYou are Claude, an equal implementation partner—not a passive approver. Inspect the isolated workspace read-only. Translate the approved action into concrete acceptance checks, identify the most likely implementation mistake, and point to the files or evidence Codex should inspect. Challenge any unsupported assumption in the agreed action. Do not edit files or run external jobs. Return a short, actionable handoff that Codex must address.`;
-}
-function implementationPrompt(sharedBrief, recommendation, collaboratorPlan) {
-    return `${sharedBrief}\n\n# User-approved proposal\n${recommendation}\n\n# Claude's independent implementation checks\n${collaboratorPlan}\n\n# Approved implementation\nYou are Codex, an equal implementation partner. Address Claude's concrete checks and explicitly explain any point you reject. Implement the smallest safe local version of the approved proposal in this project. Preserve unrelated and pre-existing changes. Follow repository instructions. Run proportionate local tests and report the exact files changed and test results. Do not submit cluster or cloud jobs, spend money, contact anyone, expose secrets, delete data, or commit/push. If the approved work needs any of those actions, stop before that step and report the blocker clearly.`;
-}
-function reviewPrompt(sharedBrief, recommendation, implementation) {
-    return `${sharedBrief}\n\n# Approved proposal\n${recommendation}\n\n# Codex implementation report\n${implementation}\n\n# Independent review\nInspect the current project read-only and review whether the implementation matches the approved scope. Check correctness, experimental leakage, confounds, missing tests, novelty claims, and whether unrelated work was disturbed. Do not edit files or run external jobs. Return only actionable findings, ordered by severity, and say explicitly if no blocking problem is found.`;
-}
-function verificationPrompt(sharedBrief, recommendation, implementation, review) {
-    return `${sharedBrief}\n\n# Approved proposal\n${recommendation}\n\n# Initial implementation report\n${implementation}\n\n# Claude review\n${review}\n\n# Verification and final report\nAddress valid review findings within the approved scope, then run the relevant local tests again. Preserve unrelated changes. Report what is now implemented, exact tests and results, remaining risks, and the next external experiment if one is still needed. Do not submit external jobs, spend money, contact anyone, commit, or push.`;
-}
-async function runCodex(prompt, projectPath, mode) {
-    const binary = await resolveCodexBinary();
-    if (!binary)
-        throw new Error("Codex local client was not found");
-    const isolatedWorkspace = join(projectPath, "workspace");
-    const executionRoot = (mode === "implement" || mode === "verify") && existsSync(join(isolatedWorkspace, ".git"))
-        ? isolatedWorkspace
-        : projectPath;
-    const tempDir = await mkdtemp(join(tmpdir(), "peon-roundtable-codex-"));
-    const outputPath = join(tempDir, "last-message.txt");
-    try {
-        const args = [
-            "exec",
-            "--ephemeral",
-            "--ignore-user-config",
-            "--sandbox",
-            mode === "implement" || mode === "verify" ? "workspace-write" : "read-only",
-            "--skip-git-repo-check",
-            "--cd",
-            executionRoot,
-            "--output-last-message",
-            outputPath,
-            "-"
-        ];
-        if (mode === "chat")
-            args.splice(3, 0, "--config", 'model_reasoning_effort="low"');
-        await spawnWithInput(binary, args, prompt, executionRoot, { rejectOnOverflow: false });
-        return await readFile(outputPath, "utf8");
-    }
-    finally {
-        await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
-    }
-}
-async function runClaude(prompt, projectPath, mode) {
-    const binary = await resolveClaudeBinary();
-    if (!binary)
-        throw new Error("Claude local client was not found");
-    const args = [
-        "-p",
-        "--safe-mode",
-        "--output-format",
-        "text",
-        "--permission-mode",
-        "plan",
-        "--tools",
-        "Read,Glob,Grep,WebSearch,WebFetch",
-        "--no-session-persistence"
-    ];
-    if (mode === "chat")
-        args.push("--effort", "low");
-    const result = await spawnWithInput(binary, args, prompt, projectPath);
-    return result.stdout;
-}
-async function spawnWithInput(binary, args, input, cwd, options = {}) {
-    const configured = Number.parseInt(process.env.PEON_ROUNDTABLE_TIMEOUT_MS ?? "", 10);
-    const timeoutMs = Number.isFinite(configured) && configured >= 10_000 ? configured : DEFAULT_TIMEOUT_MS;
-    return new Promise((resolve, reject) => {
-        const child = spawn(binary, args, { cwd, env: process.env, stdio: ["pipe", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        let overflow = false;
-        const timer = setTimeout(() => {
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 2_000).unref();
-        }, timeoutMs);
-        timer.unref();
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            const combined = stdout + chunk;
-            if (combined.length > MAX_AGENT_OUTPUT_CHARS * 4)
-                overflow = true;
-            stdout = combined.slice(-MAX_AGENT_OUTPUT_CHARS * 4);
-        });
-        child.stderr.on("data", (chunk) => {
-            const combined = stderr + chunk;
-            if (combined.length > MAX_AGENT_OUTPUT_CHARS * 4)
-                overflow = true;
-            stderr = combined.slice(-MAX_AGENT_OUTPUT_CHARS * 4);
-        });
-        child.on("error", (error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-        child.on("close", (code, signal) => {
-            clearTimeout(timer);
-            if (overflow && options.rejectOnOverflow !== false) {
-                reject(new Error(`${basename(binary)} produced too much output`));
-                return;
-            }
-            if (signal) {
-                reject(new Error(`${basename(binary)} did not finish before the local timeout`));
-                return;
-            }
-            if (code !== 0) {
-                reject(new Error(`${basename(binary)} failed: ${stderr.trim().slice(0, 500) || `exit ${code}`}`));
-                return;
-            }
-            resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
-        });
-        child.stdin.end(input);
-    });
-}
-async function resolveCodexBinary() {
-    return firstExecutable([
-        process.env.PEON_CODEX_BIN,
-        "/Applications/ChatGPT.app/Contents/Resources/codex",
-        "codex"
-    ]);
-}
-async function resolveClaudeBinary() {
-    return firstExecutable([
-        process.env.PEON_CLAUDE_BIN,
-        join(homedir(), ".local", "bin", "claude"),
-        "claude"
-    ]);
-}
-async function isCodexAuthenticated(binary) {
-    const result = await probeCommand(binary, ["login", "status"]);
-    return result.code === 0 && /logged in/i.test(`${result.stdout}\n${result.stderr}`);
-}
-async function isClaudeAuthenticated(binary) {
-    const result = await probeCommand(binary, ["auth", "status"]);
-    if (result.code !== 0)
-        return false;
-    try {
-        const parsed = JSON.parse(result.stdout);
-        return parsed.loggedIn === true;
-    }
-    catch {
-        return false;
-    }
-}
-async function probeCommand(binary, args) {
-    return new Promise((resolve) => {
-        const child = spawn(binary, args, { cwd: homedir(), env: process.env, stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        const timer = setTimeout(() => child.kill("SIGTERM"), 5_000);
-        timer.unref();
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout = `${stdout}${chunk}`.slice(-4_000);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk}`.slice(-4_000);
-        });
-        child.on("error", () => {
-            clearTimeout(timer);
-            resolve({ code: null, stdout, stderr });
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() });
-        });
-    });
-}
-async function firstExecutable(candidates) {
-    const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
-    for (const candidate of candidates) {
-        if (!candidate)
-            continue;
-        const paths = isAbsolute(candidate) ? [candidate] : pathEntries.map((entry) => join(entry, candidate));
-        for (const path of paths) {
-            try {
-                await access(path, fsConstants.X_OK);
-                return path;
-            }
-            catch {
-                // Try the next candidate.
-            }
-        }
-    }
-    return null;
-}
-function safeError(error) {
-    const message = error instanceof Error ? error.message : "Unknown roundtable error";
-    return message.replace(/[\r\n]+/g, " ").slice(0, 700);
-}
-function reportFailed(report) {
-    return /(?:\btests?\s+failed\b|\bfailing\b|\bverification\s+failed\b|\bnot\s+pass(?:ed)?\b)/i.test(report);
-}
-async function collectWorkspaceChanges(projectPath) {
-    const isolatedWorkspace = join(projectPath, "workspace");
-    const root = existsSync(join(isolatedWorkspace, ".git"))
-        ? isolatedWorkspace
-        : existsSync(join(projectPath, ".git"))
-            ? projectPath
-            : null;
-    if (!root)
-        return [];
-    const result = await probeCommandAt("git", ["status", "--short", "--untracked-files=all"], root);
-    if (result.code !== 0)
-        return [];
-    return result.stdout
-        .split("\n")
-        .map((line) => line.trimEnd())
-        .filter(Boolean)
-        .slice(0, 120);
-}
-function changedWorkspaceSnapshot(before, after) {
-    return before.join("\n") === after.join("\n") ? [] : after;
-}
-async function probeCommandAt(binary, args, cwd) {
-    return new Promise((resolve) => {
-        const child = spawn(binary, args, { cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        const timer = setTimeout(() => child.kill("SIGTERM"), 10_000);
-        timer.unref();
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout = `${stdout}${chunk}`.slice(-40_000);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk}`.slice(-4_000);
-        });
-        child.on("error", () => {
-            clearTimeout(timer);
-            resolve({ code: null, stdout, stderr });
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() });
-        });
-    });
-}