opencode-magi 0.0.0-dev-20260519011027

package/dist/orchestrator/run-manager.js

@@ -0,0 +1,1670 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rm, rmdir, writeFile, } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { outputBaseDirs, prRunOutputDir } from "../config/output";
+import { worktreeBaseDirs } from "../config/worktree";
+import { removeBranch, removeWorktree, } from "../github/commands";
+import { withGitHubApiRetry } from "../github/retry";
+import { runMerge, } from "./merge";
+import { runReview } from "./review";
+const EVENT_LAST_UPDATE_THROTTLE_MS = 5_000;
+const DEFAULT_CLEAR_OPTIONS = {
+    branch: true,
+    output: true,
+    session: true,
+    worktree: true,
+};
+function createRunId() {
+    return `run-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+function now() {
+    return new Date().toISOString();
+}
+function isActiveStatus(status) {
+    return (status === "blocked" ||
+        status === "preparing" ||
+        status === "running" ||
+        status === "posting");
+}
+function isWithinDirectory(directory, path) {
+    const relation = relative(directory, path);
+    return (relation === "" || (!relation.startsWith("..") && !isAbsolute(relation)));
+}
+async function pruneEmptyDirectories(input) {
+    const boundary = resolve(input.boundary);
+    const start = resolve(input.start);
+    if (!isWithinDirectory(boundary, start) || start === boundary)
+        return;
+    async function pruneChildren(dir) {
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const path = join(dir, entry.name);
+            await pruneChildren(path);
+            await rmdir(path).catch(() => undefined);
+        }
+    }
+    if (input.recursive)
+        await pruneChildren(start);
+    let current = start;
+    while (current !== boundary && isWithinDirectory(boundary, current)) {
+        try {
+            await rmdir(current);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT")
+                break;
+        }
+        current = dirname(current);
+    }
+}
+function reviewerArtifactBase(progressType, reviewer) {
+    return `${reviewer}.${progressType}`;
+}
+function prUrl(repository, pr) {
+    const host = repository.github.host || "github.com";
+    return `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
+}
+function prMarkdownLink(state) {
+    if (state.pr == null)
+        return state.runId;
+    return state.prUrl ? `[#${state.pr}](${state.prUrl})` : `#${state.pr}`;
+}
+function runLabel(state) {
+    return state.pr == null ? state.runId : prMarkdownLink(state);
+}
+function reviewerCompletionText(input) {
+    const reviewer = `**Reviewer ${input.reviewer}**`;
+    if (input.verdict === "MERGE") {
+        return `${reviewer} approved ${input.pr}.`;
+    }
+    if (input.verdict === "CHANGES_REQUESTED") {
+        return `${reviewer} requested changes on ${input.pr}.`;
+    }
+    if (input.verdict === "CLOSE") {
+        return `${reviewer} requested closing ${input.pr}.`;
+    }
+    return `${reviewer} finished reviewing ${input.pr}.`;
+}
+function reviewDecisionText(input) {
+    if (input.verdict === "MERGE")
+        return `Reviewers approved ${input.pr}.`;
+    if (input.verdict === "CHANGES_REQUESTED") {
+        return `Reviewers requested changes on ${input.pr}.`;
+    }
+    if (input.verdict === "CLOSE") {
+        return `Reviewers requested closing ${input.pr}.`;
+    }
+    return `Reviewers finished reviewing ${input.pr}.`;
+}
+function ciReportText(input) {
+    const failed = input.report.failed.length;
+    const rerun = input.report.rerun.length;
+    const recovered = input.report.scopeOutsideRecovered.length;
+    const unresolved = input.report.scopeOutsideUnresolved.length;
+    const scopeInside = input.report.scopeInside.length;
+    return `CI report for ${input.pr}: ${failed} failed, ${scopeInside} scope-in, ${rerun} rerun, ${recovered} recovered, ${unresolved} unresolved.`;
+}
+function closeReconsiderationText(input) {
+    if (input.to === "MERGE") {
+        return `**Reviewer ${input.reviewer}** changed their close request to approval for ${input.pr}.`;
+    }
+    if (input.to === "CHANGES_REQUESTED") {
+        return `**Reviewer ${input.reviewer}** changed their close request to changes requested for ${input.pr}.`;
+    }
+    return `**Reviewer ${input.reviewer}** reconsidered closing ${input.pr}.`;
+}
+function findingsValidationText(input) {
+    return `Validated review findings by majority for ${input.pr}: ${input.kept} kept, ${input.discarded} discarded.`;
+}
+function reviewerFailureText(input) {
+    const repairs = repairAttemptsText(input.repairAttempts);
+    return `**Reviewer ${input.reviewer}** failed reviewing ${input.pr}${repairs}: ${input.error}`;
+}
+function editorFailureText(input) {
+    const repairs = repairAttemptsText(input.repairAttempts);
+    return `**Editor** failed editing ${input.pr}${repairs}: ${input.error}`;
+}
+function repairAttemptsText(attempts) {
+    if (!attempts)
+        return "";
+    return ` after ${attempts} JSON regeneration attempt${attempts === 1 ? "" : "s"}`;
+}
+function mergePhaseText(input) {
+    if (input.phase === "fetching PR metadata") {
+        return `Fetching PR metadata for ${input.pr}.`;
+    }
+    if (input.phase === "fetching existing reviews") {
+        return `Fetching existing reviews for ${input.pr}.`;
+    }
+    if (input.phase === "waiting for checks") {
+        return `Waiting for checks for ${input.pr}.`;
+    }
+    if (input.phase === "posting reviews") {
+        return `Posting review results to GitHub for ${input.pr}.`;
+    }
+    if (input.phase === "waiting for CI checks") {
+        return `Waiting for CI checks for ${input.pr}.`;
+    }
+    if (input.phase === "CI checks passed") {
+        return `CI checks passed for ${input.pr}.`;
+    }
+    if (input.phase === "investigating failed CI checks") {
+        return `Investigating failed CI checks for ${input.pr}.`;
+    }
+    if (input.phase === "fetching failed CI logs") {
+        return `Fetching failed CI logs for ${input.pr}.`;
+    }
+    if (input.phase === "classifying CI failures") {
+        return `Classifying CI failures for ${input.pr}.`;
+    }
+    if (input.phase === "CI failures classified as scope-in") {
+        return `CI failures were classified as scope-in for ${input.pr}.`;
+    }
+    if (input.phase === "scope-out CI failures remain unresolved") {
+        return `Scope-out CI failures remain unresolved for ${input.pr}.`;
+    }
+    if (input.phase === "rerunning scope-out CI jobs") {
+        return `Rerunning scope-out CI jobs for ${input.pr}.`;
+    }
+    if (input.phase === "waiting for rerun CI checks") {
+        return `Waiting for rerun CI checks for ${input.pr}.`;
+    }
+    if (input.phase === "rerun CI checks passed") {
+        return `Rerun CI checks passed for ${input.pr}.`;
+    }
+    if (input.phase === "merging PR")
+        return `Merging ${input.pr}.`;
+    if (input.phase === "closing PR")
+        return `Closing ${input.pr}.`;
+    if (input.phase === "creating worktree") {
+        return `Creating worktree for ${input.pr}.`;
+    }
+    if (input.phase === "validating review findings") {
+        return `Validating review findings for ${input.pr}.`;
+    }
+    if (input.phase === "reconsidering close verdicts") {
+        return `Reconsidering close verdicts for ${input.pr}.`;
+    }
+    if (input.phase.startsWith("editing cycle")) {
+        return `**Editor** started editing ${input.pr}.`;
+    }
+    if (input.phase.startsWith("waiting for checks after edit")) {
+        return `Waiting for checks after editing ${input.pr}.`;
+    }
+    if (input.phase.startsWith("rereview cycle")) {
+        return `Started re-reviewing ${input.pr}.`;
+    }
+    return `Magi phase for ${input.pr}: ${input.phase}.`;
+}
+function threadLimitText(input) {
+    const links = input.threads
+        .map((thread) => `[${thread.label}](${thread.url})`)
+        .join(", ");
+    if (input.threads.length === 1) {
+        return `Review thread ${links} reached the resolution attempt limit for ${input.pr}.`;
+    }
+    return `Review threads ${links} reached the resolution attempt limit for ${input.pr}.`;
+}
+function extractSessionId(properties) {
+    if (!properties)
+        return undefined;
+    const direct = properties.sessionID ?? properties.sessionId;
+    if (typeof direct === "string")
+        return direct;
+    const info = properties.info;
+    if (info && typeof info === "object") {
+        const value = info
+            .sessionID ??
+            info
+                .sessionId ??
+            info.id;
+        if (typeof value === "string")
+            return value;
+    }
+    const part = properties.part;
+    if (part && typeof part === "object") {
+        const value = part.sessionID ??
+            part.sessionId;
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+function extractToolPart(properties) {
+    if (!properties)
+        return undefined;
+    const part = properties.part && typeof properties.part === "object"
+        ? properties.part
+        : properties;
+    const type = typeof part.type === "string" ? part.type : undefined;
+    const tool = typeof part.tool === "string" ? part.tool : undefined;
+    const state = part.state && typeof part.state === "object"
+        ? part.state
+        : undefined;
+    if (!tool && type !== "tool")
+        return undefined;
+    return {
+        callId: typeof part.callID === "string" ? part.callID : undefined,
+        id: typeof part.id === "string" ? part.id : undefined,
+        input: state?.input && typeof state.input === "object"
+            ? state.input
+            : undefined,
+        status: typeof state?.status === "string" ? state.status : undefined,
+        tool,
+    };
+}
+function extractQuestions(input) {
+    return Array.isArray(input?.questions) ? input.questions : undefined;
+}
+function formatQuestionRequest(question) {
+    if (!question?.questions?.length)
+        return undefined;
+    return question.questions
+        .map((item, index) => {
+        if (!item || typeof item !== "object")
+            return `${index + 1}. ${String(item)}`;
+        const record = item;
+        const header = typeof record.header === "string" ? record.header : undefined;
+        const text = typeof record.question === "string" ? record.question : undefined;
+        const options = Array.isArray(record.options)
+            ? record.options
+                .map((option) => {
+                if (!option || typeof option !== "object")
+                    return undefined;
+                const label = option.label;
+                return typeof label === "string" ? label : undefined;
+            })
+                .filter((value) => Boolean(value))
+            : [];
+        const suffix = options.length ? ` Options: ${options.join(", ")}.` : "";
+        return `${index + 1}. ${header ? `${header}: ` : ""}${text ?? JSON.stringify(item)}${suffix}`;
+    })
+        .join("\n");
+}
+function questionWaitText(input) {
+    const details = formatQuestionRequest(input.question);
+    const request = input.question?.id ? ` Request: ${input.question.id}.` : "";
+    return [
+        `Magi ${input.agent} is waiting for a question answer on ${input.pr}.${request}`,
+        details
+            ? `Question:\n${details}`
+            : "Question details were not included in the event.",
+    ].join("\n");
+}
+function extractPermissionRequest(properties) {
+    if (!properties)
+        return undefined;
+    const sessionId = extractSessionId(properties);
+    const id = typeof properties.id === "string"
+        ? properties.id
+        : typeof properties.requestID === "string"
+            ? properties.requestID
+            : typeof properties.permissionID === "string"
+                ? properties.permissionID
+                : undefined;
+    const permission = typeof properties.permission === "string"
+        ? properties.permission
+        : typeof properties.type === "string"
+            ? properties.type
+            : undefined;
+    const patterns = Array.isArray(properties.patterns)
+        ? properties.patterns.filter((item) => typeof item === "string")
+        : undefined;
+    const tool = typeof properties.tool === "string"
+        ? properties.tool
+        : properties.tool && typeof properties.tool === "object"
+            ? typeof properties.tool.name === "string"
+                ? properties.tool.name
+                : undefined
+            : undefined;
+    if (!sessionId && !id && !permission && !tool)
+        return undefined;
+    return { id, patterns, permission, sessionId, tool };
+}
+function extractQuestionRequest(properties) {
+    if (!properties)
+        return undefined;
+    const sessionId = extractSessionId(properties);
+    const id = typeof properties.id === "string"
+        ? properties.id
+        : typeof properties.requestID === "string"
+            ? properties.requestID
+            : typeof properties.questionID === "string"
+                ? properties.questionID
+                : undefined;
+    const questions = Array.isArray(properties.questions)
+        ? properties.questions
+        : undefined;
+    const tool = typeof properties.tool === "string"
+        ? properties.tool
+        : properties.tool && typeof properties.tool === "object"
+            ? typeof properties.tool.name === "string"
+                ? properties.tool.name
+                : undefined
+            : undefined;
+    if (!sessionId && !id && !questions && !tool)
+        return undefined;
+    return { id, questions, sessionId, tool };
+}
+export class MagiRunManager {
+    input;
+    active = new Map();
+    countedToolParts = new Map();
+    controllers = new Map();
+    eventLastUpdates = new Map();
+    notifiedPermissions = new Map();
+    runPaths = new Map();
+    outputDirs = new Set();
+    sessionToRun = new Map();
+    constructor(input) {
+        this.input = input;
+    }
+    async startReview(input) {
+        const runId = createRunId();
+        const outputDir = prRunOutputDir({
+            config: input.config,
+            directory: this.input.directory,
+            pr: input.pr,
+            runId,
+        });
+        const createdAt = now();
+        const state = {
+            command: "review",
+            createdAt,
+            dryRun: input.dryRun,
+            outputDir,
+            parentSessionId: input.parentSessionId,
+            phase: "queued",
+            pr: input.pr,
+            prUrl: prUrl(input.repository, input.pr),
+            repository: input.repository.alias,
+            reviewers: Object.fromEntries(input.repository.agents.reviewers.map((reviewer) => [
+                reviewer.key,
+                {
+                    account: reviewer.account,
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                },
+            ])),
+            runId,
+            status: "preparing",
+            updatedAt: createdAt,
+        };
+        this.active.set(runId, state);
+        this.runPaths.set(runId, join(outputDir, "state.json"));
+        for (const dir of outputBaseDirs(this.input.directory, input.config))
+            this.outputDirs.add(dir);
+        await this.persist(state);
+        await this.notify(state, `Started Magi review for ${prMarkdownLink(state)}.`);
+        const controller = new AbortController();
+        this.controllers.set(runId, controller);
+        void this.executeReview({
+            ...input,
+            runId,
+            signal: controller.signal,
+        }).catch(async (error) => {
+            await this.failRun(runId, error);
+        });
+        return state;
+    }
+    async startMerge(input) {
+        const runId = createRunId();
+        const outputDir = prRunOutputDir({
+            config: input.config,
+            directory: this.input.directory,
+            pr: input.pr,
+            runId,
+        });
+        const createdAt = now();
+        const editor = input.repository.agents.editor;
+        const state = {
+            command: "merge",
+            createdAt,
+            dryRun: input.dryRun,
+            editor: editor
+                ? {
+                    account: editor.account,
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                }
+                : undefined,
+            outputDir,
+            parentSessionId: input.parentSessionId,
+            phase: "queued",
+            pr: input.pr,
+            prUrl: prUrl(input.repository, input.pr),
+            repository: input.repository.alias,
+            reviewers: Object.fromEntries(input.repository.agents.reviewers.map((reviewer) => [
+                reviewer.key,
+                {
+                    account: reviewer.account,
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                },
+            ])),
+            runId,
+            status: "preparing",
+            updatedAt: createdAt,
+        };
+        this.active.set(runId, state);
+        this.runPaths.set(runId, join(outputDir, "state.json"));
+        for (const dir of outputBaseDirs(this.input.directory, input.config))
+            this.outputDirs.add(dir);
+        await this.persist(state);
+        await this.notify(state, `Started Magi merge for ${prMarkdownLink(state)}.`);
+        const controller = new AbortController();
+        this.controllers.set(runId, controller);
+        void this.executeMerge({
+            ...input,
+            runId,
+            signal: controller.signal,
+        }).catch(async (error) => {
+            await this.failRun(runId, error);
+        });
+        return state;
+    }
+    async status(input = {}) {
+        const timeoutMs = Math.min(input.timeoutMs ?? 60_000, 600_000);
+        const startedAt = Date.now();
+        while (input.block) {
+            const states = await this.filteredStates(input);
+            if (states.length &&
+                states.every((state) => !isActiveStatus(state.status)))
+                return states;
+            if (Date.now() - startedAt >= timeoutMs)
+                return states;
+            await new Promise((resolve) => setTimeout(resolve, 1_000));
+        }
+        return this.filteredStates(input);
+    }
+    hasSession(sessionId) {
+        return this.sessionToRun.has(sessionId);
+    }
+    async output(input) {
+        const state = await this.selectState(input);
+        if (!state)
+            return `Magi run not found: ${this.selectorText(input)}`;
+        if (input.reviewer) {
+            const reviewer = this.agentState(state, input.reviewer);
+            if (!reviewer)
+                return `Agent not found in ${this.selectorText(input)}: ${input.reviewer}`;
+            const sections = [
+                `# ${input.reviewer}`,
+                `status: ${reviewer.status}`,
+                reviewer.sessionId ? `session: ${reviewer.sessionId}` : undefined,
+                reviewer.verdict ? `verdict: ${reviewer.verdict}` : undefined,
+                reviewer.error ? `error: ${reviewer.error}` : undefined,
+            ].filter(Boolean);
+            if (reviewer.parsedPath) {
+                sections.push("\n## Parsed");
+                sections.push(await readFile(reviewer.parsedPath, "utf8").catch(() => "(missing parsed artifact)"));
+            }
+            if (reviewer.rawPath) {
+                sections.push("\n## Raw");
+                sections.push(await readFile(reviewer.rawPath, "utf8").catch(() => "(missing raw artifact)"));
+            }
+            return sections.join("\n");
+        }
+        const sections = [this.formatStates([state], { verbose: true })];
+        if (state.reportPath) {
+            sections.push("\n## Report");
+            sections.push(await readFile(state.reportPath, "utf8").catch(() => "(missing report artifact)"));
+        }
+        const output = sections.join("\n");
+        return output;
+    }
+    async cancel(input) {
+        const selector = typeof input === "string" ? { runId: input } : input;
+        const state = await this.selectState(selector);
+        if (!state)
+            return undefined;
+        const runId = state.runId;
+        this.controllers.get(runId)?.abort();
+        state.status = "cancelled";
+        state.phase = "cancelled";
+        state.completedAt = now();
+        if (state.editor?.status === "pending" ||
+            state.editor?.status === "running" ||
+            state.editor?.status === "repairing") {
+            state.editor.status = "cancelled";
+        }
+        if (state.editor?.sessionId) {
+            await this.input.client.session
+                .abort?.({ path: { id: state.editor.sessionId } })
+                .catch(() => undefined);
+        }
+        for (const reviewer of Object.values(state.reviewers)) {
+            if (reviewer.status === "pending" ||
+                reviewer.status === "running" ||
+                reviewer.status === "repairing" ||
+                reviewer.status === "blocked") {
+                reviewer.status = "cancelled";
+            }
+            if (reviewer.sessionId) {
+                await this.input.client.session
+                    .abort?.({ path: { id: reviewer.sessionId } })
+                    .catch(() => undefined);
+            }
+        }
+        for (const classifier of Object.values(state.ciClassifiers ?? {})) {
+            if (classifier.status === "pending" ||
+                classifier.status === "running" ||
+                classifier.status === "repairing" ||
+                classifier.status === "blocked") {
+                classifier.status = "cancelled";
+            }
+            if (classifier.sessionId) {
+                await this.input.client.session
+                    .abort?.({ path: { id: classifier.sessionId } })
+                    .catch(() => undefined);
+            }
+        }
+        if (state.worktreePath) {
+            await removeWorktree(this.input.exec, state.worktreePath).catch(() => undefined);
+        }
+        await this.persist(state);
+        await this.notify(state, `Cancelled ${state.command} for ${runLabel(state)}.`, { reply: true });
+        this.active.delete(runId);
+        this.controllers.delete(runId);
+        return state;
+    }
+    async clear(input) {
+        const configured = input.options ?? {};
+        const options = {
+            branch: configured.branch ?? DEFAULT_CLEAR_OPTIONS.branch,
+            output: configured.output ?? DEFAULT_CLEAR_OPTIONS.output,
+            session: configured.session ?? DEFAULT_CLEAR_OPTIONS.session,
+            worktree: configured.worktree ?? DEFAULT_CLEAR_OPTIONS.worktree,
+        };
+        const states = await this.filteredStates(input);
+        const cleanupDirs = new Set(this.absoluteWorktreeDirs(input));
+        const cleanupTrees = new Set(this.emptyOutputCleanupRoots(input));
+        const summary = {
+            branchDeleted: 0,
+            branchFailed: 0,
+            branchSkipped: 0,
+            outputDeleted: 0,
+            outputFailed: 0,
+            runsCleared: 0,
+            runsSkippedActive: 0,
+            sessionDeleted: 0,
+            sessionFailed: 0,
+            worktreeDeleted: 0,
+            worktreeFailed: 0,
+        };
+        const lines = [];
+        if (!states.length) {
+            await this.pruneEmptyMagiDirectories({
+                dirs: cleanupDirs,
+                trees: cleanupTrees,
+            });
+            return `No Magi runs found: ${this.selectorText(input)}`;
+        }
+        for (const state of states) {
+            if (isActiveStatus(state.status)) {
+                summary.runsSkippedActive += 1;
+                lines.push(`Skipped active run ${state.runId} for ${runLabel(state)}: ${state.status}`);
+                continue;
+            }
+            if (options.session) {
+                if (!this.input.client.session.delete) {
+                    summary.sessionFailed += this.collectSessionIds(state).length;
+                    lines.push("OpenCode client does not support session deletion.");
+                }
+                else {
+                    for (const sessionId of this.collectSessionIds(state)) {
+                        try {
+                            await this.input.client.session.delete({
+                                path: { id: sessionId },
+                            });
+                            summary.sessionDeleted += 1;
+                        }
+                        catch (error) {
+                            summary.sessionFailed += 1;
+                            lines.push(`Failed to delete session ${sessionId}: ${error.message}`);
+                        }
+                    }
+                }
+            }
+            if (options.worktree && state.worktreePath) {
+                let removed = false;
+                let unregisterError;
+                try {
+                    await removeWorktree(this.input.exec, state.worktreePath);
+                    removed = true;
+                }
+                catch (error) {
+                    unregisterError = error;
+                }
+                try {
+                    await rm(state.worktreePath, { force: true, recursive: true });
+                    removed = true;
+                }
+                catch (error) {
+                    summary.worktreeFailed += 1;
+                    if (unregisterError) {
+                        lines.push(`Failed to unregister worktree ${state.worktreePath}: ${unregisterError.message}`);
+                    }
+                    lines.push(`Failed to delete worktree directory ${state.worktreePath}: ${error.message}`);
+                }
+                if (removed)
+                    summary.worktreeDeleted += 1;
+                cleanupDirs.add(state.worktreePath);
+            }
+            if (options.branch) {
+                if (state.worktreeBranch) {
+                    try {
+                        await removeBranch(this.input.exec, state.worktreeBranch);
+                        summary.branchDeleted += 1;
+                    }
+                    catch (error) {
+                        summary.branchFailed += 1;
+                        lines.push(`Failed to delete branch ${state.worktreeBranch}: ${error.message}`);
+                    }
+                }
+                else {
+                    summary.branchSkipped += 1;
+                }
+            }
+            if (options.output) {
+                try {
+                    await rm(state.outputDir, { force: true, recursive: true });
+                    summary.outputDeleted += 1;
+                    cleanupDirs.add(state.outputDir);
+                }
+                catch (error) {
+                    summary.outputFailed += 1;
+                    lines.push(`Failed to delete output ${state.outputDir}: ${error.message}`);
+                }
+            }
+            this.active.delete(state.runId);
+            this.controllers.delete(state.runId);
+            this.runPaths.delete(state.runId);
+            summary.runsCleared += 1;
+            lines.push(`Cleared run ${state.runId} for ${runLabel(state)}.`);
+        }
+        await this.pruneEmptyMagiDirectories({
+            dirs: cleanupDirs,
+            trees: cleanupTrees,
+        });
+        return this.formatClearSummary(summary, lines);
+    }
+    async replyPermission(input) {
+        const state = await this.selectState(input);
+        if (!state)
+            return `Magi run not found: ${this.selectorText(input)}`;
+        const selected = this.selectPendingAgent(state, "permission", input.agent, input.requestId);
+        if (typeof selected === "string")
+            return selected;
+        const requestId = input.requestId ?? selected.state.pendingPermission?.id;
+        if (!requestId)
+            return `Permission request id not found for ${selected.key}.`;
+        if (!this.input.client.permission?.reply) {
+            return "OpenCode client does not support permission replies.";
+        }
+        await this.input.client.permission.reply({
+            requestID: requestId,
+            reply: input.reply,
+        });
+        selected.state.pendingPermission = undefined;
+        if (!selected.state.pendingQuestion &&
+            selected.state.status === "blocked") {
+            selected.state.status = "running";
+        }
+        if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+            state.status = "running";
+        }
+        await this.persist(state);
+        return `Replied to permission request ${requestId} for ${selected.key}: ${input.reply}.`;
+    }
+    async replyQuestion(input) {
+        const state = await this.selectState(input);
+        if (!state)
+            return `Magi run not found: ${this.selectorText(input)}`;
+        const selected = this.selectPendingAgent(state, "question", input.agent, input.requestId);
+        if (typeof selected === "string")
+            return selected;
+        const requestId = input.requestId ?? selected.state.pendingQuestion?.id;
+        if (!requestId)
+            return `Question request id not found for ${selected.key}.`;
+        if (!this.input.client.question?.reply) {
+            return "OpenCode client does not support question replies.";
+        }
+        await this.input.client.question.reply({
+            answers: input.answers,
+            requestID: requestId,
+        });
+        selected.state.pendingQuestion = undefined;
+        if (!selected.state.pendingPermission &&
+            selected.state.status === "blocked") {
+            selected.state.status = "running";
+        }
+        if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+            state.status = "running";
+        }
+        await this.persist(state);
+        return `Replied to question request ${requestId} for ${selected.key}.`;
+    }
+    async rejectQuestion(input) {
+        const state = await this.selectState(input);
+        if (!state)
+            return `Magi run not found: ${this.selectorText(input)}`;
+        const selected = this.selectPendingAgent(state, "question", input.agent, input.requestId);
+        if (typeof selected === "string")
+            return selected;
+        const requestId = input.requestId ?? selected.state.pendingQuestion?.id;
+        if (!requestId)
+            return `Question request id not found for ${selected.key}.`;
+        if (!this.input.client.question?.reject) {
+            return "OpenCode client does not support question rejection.";
+        }
+        await this.input.client.question.reject({ requestID: requestId });
+        selected.state.pendingQuestion = undefined;
+        if (!selected.state.pendingPermission &&
+            selected.state.status === "blocked") {
+            selected.state.status = "running";
+        }
+        if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+            state.status = "running";
+        }
+        await this.persist(state);
+        return `Rejected question request ${requestId} for ${selected.key}.`;
+    }
+    async handleEvent(input) {
+        const sessionId = extractSessionId(input.event.properties);
+        if (!sessionId)
+            return;
+        const mapping = this.sessionToRun.get(sessionId);
+        if (!mapping)
+            return;
+        const state = this.active.get(mapping.runId) ??
+            (await this.readStateByRunId(mapping.runId));
+        if (!state)
+            return;
+        const agent = this.agentState(state, mapping.agent);
+        if (!agent)
+            return;
+        let dirty = false;
+        const receivedAt = now();
+        const receivedAtMs = Date.now();
+        const markUpdated = (force = false) => {
+            const last = this.eventLastUpdates.get(sessionId) ?? 0;
+            if (!force && receivedAtMs - last < EVENT_LAST_UPDATE_THROTTLE_MS)
+                return;
+            agent.lastUpdate = receivedAt;
+            this.eventLastUpdates.set(sessionId, receivedAtMs);
+            dirty = true;
+        };
+        const toolPart = extractToolPart(input.event.properties);
+        if (toolPart) {
+            const counted = this.countedToolParts.get(sessionId) ?? new Set();
+            if (!toolPart.id || !counted.has(toolPart.id)) {
+                agent.toolCalls += 1;
+                if (toolPart.id)
+                    counted.add(toolPart.id);
+                this.countedToolParts.set(sessionId, counted);
+                markUpdated(true);
+                dirty = true;
+            }
+        }
+        if (input.event.type === "message.part.updated" &&
+            toolPart?.tool === "question" &&
+            (toolPart.status === "pending" || toolPart.status === "running")) {
+            const existing = agent.pendingQuestion;
+            const question = {
+                id: toolPart.id ?? toolPart.callId,
+                questions: extractQuestions(toolPart.input),
+                sessionId,
+                tool: toolPart.tool,
+            };
+            agent.pendingQuestion = question;
+            agent.status = "blocked";
+            state.status = "blocked";
+            agent.error = "Question is waiting for an answer.";
+            markUpdated(true);
+            dirty = true;
+            if (!existing) {
+                await this.notify(state, questionWaitText({
+                    agent: mapping.agent,
+                    pr: prMarkdownLink(state),
+                    question,
+                }), { reply: true });
+            }
+        }
+        if (input.event.type === "permission.asked" ||
+            input.event.type === "permission.updated") {
+            const permission = extractPermissionRequest(input.event.properties);
+            const notified = this.notifiedPermissions.get(sessionId) ?? new Set();
+            const permissionId = permission?.id ?? `${mapping.agent}:${Date.now()}`;
+            if (!notified.has(permissionId)) {
+                notified.add(permissionId);
+                this.notifiedPermissions.set(sessionId, notified);
+                agent.pendingPermission = permission;
+                agent.status = "blocked";
+                state.status = "blocked";
+                agent.error = `Permission ${permission?.permission ?? "request"} is waiting for approval.`;
+                markUpdated(true);
+                dirty = true;
+                await this.notify(state, `Magi ${mapping.agent} is waiting for permission on ${prMarkdownLink(state)}: ${agent.error}`, { reply: true });
+            }
+        }
+        if (input.event.type === "question.asked") {
+            const question = extractQuestionRequest(input.event.properties);
+            const notified = this.notifiedPermissions.get(sessionId) ?? new Set();
+            const questionId = question?.id ?? `${mapping.agent}:${Date.now()}`;
+            if (agent.pendingQuestion) {
+                agent.pendingQuestion = question;
+                markUpdated(true);
+                dirty = true;
+            }
+            else if (!notified.has(questionId)) {
+                notified.add(questionId);
+                this.notifiedPermissions.set(sessionId, notified);
+                agent.pendingQuestion = question;
+                agent.status = "blocked";
+                state.status = "blocked";
+                agent.error = "Question is waiting for an answer.";
+                markUpdated(true);
+                dirty = true;
+                await this.notify(state, questionWaitText({
+                    agent: mapping.agent,
+                    pr: prMarkdownLink(state),
+                    question,
+                }), { reply: true });
+            }
+        }
+        if ((input.event.type === "permission.replied" ||
+            input.event.type === "permission.rejected") &&
+            agent.pendingPermission) {
+            agent.pendingPermission = undefined;
+            if (!agent.pendingQuestion && agent.status === "blocked") {
+                agent.status = "running";
+            }
+            if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+                state.status = "running";
+            }
+            markUpdated(true);
+            dirty = true;
+        }
+        if ((input.event.type === "question.replied" ||
+            input.event.type === "question.rejected") &&
+            agent.pendingQuestion) {
+            agent.pendingQuestion = undefined;
+            if (!agent.pendingPermission && agent.status === "blocked") {
+                agent.status = "running";
+            }
+            if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+                state.status = "running";
+            }
+            markUpdated(true);
+            dirty = true;
+        }
+        if (input.event.type === "message.part.updated" &&
+            toolPart?.tool === "question" &&
+            (toolPart.status === "completed" || toolPart.status === "error") &&
+            agent.pendingQuestion?.tool === "question") {
+            agent.pendingQuestion = undefined;
+            if (!agent.pendingPermission && agent.status === "blocked") {
+                agent.status = "running";
+            }
+            if (state.status === "blocked" && !this.hasBlockedAgents(state)) {
+                state.status = "running";
+            }
+            markUpdated(true);
+            dirty = true;
+        }
+        if (input.event.type === "permission.replied" &&
+            agent.status === "blocked") {
+            agent.status = "running";
+            markUpdated(true);
+            dirty = true;
+        }
+        if (input.event.type === "session.error") {
+            agent.status = "failed";
+            agent.error = JSON.stringify(input.event.properties?.error ?? "session error");
+            markUpdated(true);
+            dirty = true;
+        }
+        if (!dirty)
+            markUpdated();
+        if (dirty)
+            await this.persist(state);
+    }
+    formatStates(states, options = {}) {
+        if (!states.length)
+            return "No Magi runs found.";
+        return states
+            .map((state) => {
+            const editorLine = state.editor
+                ? this.formatAgentLine("editor", state.editor, options)
+                : undefined;
+            const reviewerLines = Object.entries(state.reviewers).map(([key, reviewer]) => {
+                return this.formatAgentLine(key, reviewer, options);
+            });
+            const classifierLines = Object.entries(state.ciClassifiers ?? {}).map(([key, classifier]) => this.formatAgentLine(`ci:${key}`, classifier, options));
+            const lines = [
+                options.verbose ? `Run: ${state.runId}` : undefined,
+                state.pr == null ? undefined : `PR: #${state.pr}`,
+                `Command: ${state.command}`,
+                state.dryRun ? "Dry run: true" : undefined,
+                `Status: ${state.status}`,
+                `Phase: ${state.phase}`,
+                state.verdict ? `Verdict: ${state.verdict}` : undefined,
+                state.error ? `Error: ${state.error}` : undefined,
+                ...(state.ciReports ?? []).flatMap((report) => [
+                    ...report.scopeOutsideRecovered.map((item) => `CI scope outside recovered: ${item.check.name}${report.attempts ? ` (recovered after ${report.attempts} retry attempt${report.attempts === 1 ? "" : "s"})` : ""} - ${item.reason}`),
+                    ...report.scopeOutsideUnresolved.map((item) => `CI scope outside unresolved: ${item.check.name}${report.attempts ? ` (${report.attempts} retry attempt${report.attempts === 1 ? "" : "s"})` : ""} - ${item.reason}`),
+                    ...report.scopeInside.map((item) => `CI scope inside: ${item.check.name} - ${item.reason}`),
+                ]),
+                ...(state.warnings ?? []).map((warning) => `Warning: ${warning}`),
+                options.verbose && state.threadAttempts
+                    ? `Thread attempts: ${Object.keys(state.threadAttempts).length} tracked, ${Object.values(state.threadAttempts).filter((attempt) => attempt.exhaustedAtCycle != null).length} exhausted`
+                    : undefined,
+                options.verbose ? `Artifacts: ${state.outputDir}` : undefined,
+                options.verbose && state.reportPath
+                    ? `Report: ${state.reportPath}`
+                    : undefined,
+                editorLine,
+                ...classifierLines,
+                ...reviewerLines,
+            ];
+            return lines.filter(Boolean).join("\n");
+        })
+            .join("\n\n");
+    }
+    async formatStatesWithReports(states, options = {}) {
+        const sections = [this.formatStates(states, options)];
+        if (!options.verbose)
+            return sections[0];
+        for (const state of states) {
+            if (state.status !== "completed" || !state.reportPath)
+                continue;
+            const report = await readFile(state.reportPath, "utf8").catch(() => "(missing report artifact)");
+            sections.push([
+                `Report for ${runLabel(state)} (${state.runId}):`,
+                "",
+                report.trimEnd(),
+            ].join("\n"));
+        }
+        return sections.join("\n\n");
+    }
+    collectSessionIds(state) {
+        const ids = [
+            state.editor?.sessionId,
+            ...Object.values(state.reviewers).map((reviewer) => reviewer.sessionId),
+            ...Object.values(state.ciClassifiers ?? {}).map((classifier) => classifier.sessionId),
+            ...Object.values(state.sessionIds ?? {}),
+            ...(state.ciReports ?? []).flatMap((report) => (report.classifierRuns ?? []).map((run) => run.sessionId)),
+        ].filter((id) => Boolean(id));
+        return [...new Set(ids)];
+    }
+    formatClearSummary(summary, lines) {
+        return [
+            `Cleared Magi runs: ${summary.runsCleared}`,
+            `Skipped active runs: ${summary.runsSkippedActive}`,
+            `Sessions deleted: ${summary.sessionDeleted}${summary.sessionFailed ? ` (${summary.sessionFailed} failed)` : ""}`,
+            `Worktrees deleted: ${summary.worktreeDeleted}${summary.worktreeFailed ? ` (${summary.worktreeFailed} failed)` : ""}`,
+            `Branches deleted: ${summary.branchDeleted}${summary.branchFailed ? ` (${summary.branchFailed} failed)` : ""}${summary.branchSkipped ? `, ${summary.branchSkipped} skipped` : ""}`,
+            `Outputs deleted: ${summary.outputDeleted}${summary.outputFailed ? ` (${summary.outputFailed} failed)` : ""}`,
+            ...lines.map((line) => `- ${line}`),
+        ].join("\n");
+    }
+    formatAgentLine(key, agent, options) {
+        const details = [
+            agent.verdict,
+            options.verbose && agent.sessionId
+                ? `session=${agent.sessionId}`
+                : undefined,
+            options.verbose && agent.toolCalls
+                ? `tools=${agent.toolCalls}`
+                : undefined,
+            options.verbose && agent.repairAttempts
+                ? `repairs=${agent.repairAttempts}`
+                : undefined,
+            options.verbose && agent.pendingPermission
+                ? `pendingPermission=${agent.pendingPermission.id ?? agent.pendingPermission.permission ?? "unknown"}`
+                : undefined,
+            options.verbose && agent.pendingQuestion
+                ? `pendingQuestion=${agent.pendingQuestion.id ?? "unknown"}`
+                : undefined,
+        ].filter(Boolean);
+        return `- ${key}: ${agent.status}${details.length ? ` (${details.join(", ")})` : ""}`;
+    }
+    agentState(state, key) {
+        if (key.startsWith("ci:"))
+            return state.ciClassifiers?.[key.slice(3)];
+        return key === "editor" ? state.editor : state.reviewers[key];
+    }
+    agentEntries(state) {
+        return [
+            ...(state.editor
+                ? [["editor", state.editor]]
+                : []),
+            ...Object.entries(state.ciClassifiers ?? {}).map(([key, value]) => [`ci:${key}`, value]),
+            ...Object.entries(state.reviewers),
+        ];
+    }
+    selectPendingAgent(state, kind, key, requestId) {
+        const entries = key
+            ? this.agentState(state, key)
+                ? [[key, this.agentState(state, key)]]
+                : []
+            : this.agentEntries(state);
+        const matches = entries.filter(([, agent]) => {
+            const pending = kind === "permission" ? agent.pendingPermission : agent.pendingQuestion;
+            if (!pending)
+                return false;
+            return !requestId || pending.id === requestId;
+        });
+        if (!matches.length) {
+            return key
+                ? `No pending ${kind} request found for ${key}.`
+                : `No pending ${kind} request found for ${prMarkdownLink(state)}.`;
+        }
+        if (matches.length > 1) {
+            return `Multiple pending ${kind} requests found for ${prMarkdownLink(state)}. Specify agent or requestId.`;
+        }
+        return { key: matches[0][0], state: matches[0][1] };
+    }
+    hasBlockedAgents(state) {
+        return this.agentEntries(state).some(([, agent]) => agent.status === "blocked");
+    }
+    async executeReview(input) {
+        const result = await runReview({
+            client: this.input.client,
+            config: input.config,
+            directory: this.input.directory,
+            dryRun: input.dryRun,
+            exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
+            onProgress: (progress) => this.applyReviewProgress(input.runId, progress),
+            pr: input.pr,
+            repository: input.repository,
+            runId: input.runId,
+            signal: input.signal,
+        });
+        const state = this.active.get(input.runId);
+        if (!state)
+            return;
+        if (state.status === "cancelled")
+            return;
+        state.status = "completed";
+        state.phase = "completed";
+        state.completedAt = now();
+        state.verdict = result.verdict;
+        state.majority = result.verdict;
+        state.posted = result.posted;
+        state.reportPath = join(state.outputDir, "report.md");
+        state.sessionIds = result.sessionIds;
+        for (const [key, output] of Object.entries(result.outputs)) {
+            const reviewer = state.reviewers[key];
+            if (!reviewer)
+                continue;
+            reviewer.status = "completed";
+            reviewer.verdict = output.verdict;
+            const artifact = "resolve" in output
+                ? reviewerArtifactBase("rereview", key)
+                : reviewerArtifactBase("review", key);
+            reviewer.rawPath = join(state.outputDir, `${artifact}.raw.txt`);
+            reviewer.parsedPath = join(state.outputDir, `${artifact}.json`);
+        }
+        for (const [key, posted] of Object.entries(result.posted)) {
+            const reviewer = state.reviewers[key];
+            if (!reviewer || !posted.startsWith("skipped:"))
+                continue;
+            reviewer.status = "skipped";
+        }
+        await this.persist(state);
+        if (result.worktreePath) {
+            await removeWorktree(this.input.exec, result.worktreePath).catch(() => undefined);
+        }
+        if (state.worktreeBranch) {
+            await removeBranch(this.input.exec, state.worktreeBranch).catch(() => undefined);
+        }
+        await this.notify(state, [`Finished reviewing ${prMarkdownLink(state)}.`, "", result.report].join("\n"), { reply: true });
+        this.active.delete(input.runId);
+        this.controllers.delete(input.runId);
+    }
+    async executeMerge(input) {
+        const result = await runMerge({
+            client: this.input.client,
+            config: input.config,
+            directory: this.input.directory,
+            dryRun: input.dryRun,
+            exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
+            onProgress: (progress) => this.applyMergeProgress(input.runId, progress),
+            pr: input.pr,
+            repository: input.repository,
+            runId: input.runId,
+            signal: input.signal,
+        });
+        const state = this.active.get(input.runId);
+        if (!state)
+            return;
+        if (state.status === "cancelled")
+            return;
+        state.status = "completed";
+        state.phase = result.status;
+        state.completedAt = now();
+        state.verdict = result.status;
+        state.reportPath = join(state.outputDir, "report.md");
+        if (state.editor?.status === "pending")
+            state.editor.status = "skipped";
+        await this.persist(state);
+        await this.notify(state, [
+            `Finished merge workflow for ${prMarkdownLink(state)}.`,
+            "",
+            result.report,
+        ].join("\n"), { reply: true });
+        this.active.delete(input.runId);
+        this.controllers.delete(input.runId);
+    }
+    async applyReviewProgress(runId, progress) {
+        const state = this.active.get(runId);
+        if (!state)
+            return;
+        state.updatedAt = now();
+        if (progress.type === "phase") {
+            state.phase = progress.phase;
+            state.status =
+                progress.phase === "posting reviews" ? "posting" : "running";
+        }
+        if (progress.type === "ci_report") {
+            state.ciReports = [...(state.ciReports ?? []), progress.report];
+        }
+        if (progress.type === "ci_classifier_started") {
+            state.ciClassifiers ??= {};
+            state.ciClassifiers[progress.reviewer] = {
+                account: progress.reviewer,
+                promptPath: progress.promptPath,
+                repairAttempts: 0,
+                status: "running",
+                toolCalls: 0,
+            };
+        }
+        if (progress.type === "ci_classifier_session") {
+            state.ciClassifiers ??= {};
+            const classifier = state.ciClassifiers[progress.reviewer] ??
+                (state.ciClassifiers[progress.reviewer] = {
+                    account: progress.reviewer,
+                    repairAttempts: 0,
+                    status: "running",
+                    toolCalls: 0,
+                });
+            classifier.sessionId = progress.sessionId;
+            classifier.status = "running";
+            classifier.lastUpdate = now();
+            this.sessionToRun.set(progress.sessionId, {
+                agent: `ci:${progress.reviewer}`,
+                runId,
+            });
+        }
+        if (progress.type === "ci_classifier_repair") {
+            const classifier = state.ciClassifiers?.[progress.reviewer];
+            if (classifier) {
+                classifier.repairAttempts += 1;
+                classifier.status = "repairing";
+                classifier.lastUpdate = now();
+            }
+        }
+        if (progress.type === "ci_classifier_completed") {
+            const classifier = state.ciClassifiers?.[progress.reviewer];
+            if (classifier) {
+                classifier.classification = progress.classification;
+                classifier.rawPath = progress.rawPath;
+                classifier.reason = progress.reason;
+                classifier.sessionId = progress.sessionId;
+                classifier.status = "completed";
+                classifier.lastUpdate = now();
+            }
+        }
+        if (progress.type === "ci_classifier_failed") {
+            const classifier = state.ciClassifiers?.[progress.reviewer];
+            if (classifier) {
+                classifier.error = progress.error;
+                classifier.status = "failed";
+                classifier.lastUpdate = now();
+            }
+        }
+        if (progress.type === "worktree_created") {
+            state.worktreePath = progress.worktreePath;
+            state.worktreeBranch = progress.branch;
+        }
+        if (progress.type === "reviewer_started") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.status = "running";
+        }
+        if (progress.type === "reviewer_skipped") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.status = "skipped";
+            reviewer.verdict = progress.verdict;
+        }
+        if (progress.type === "reviewer_session") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            if (progress.options)
+                this.input.setSessionOptions?.(progress.sessionId, progress.options);
+            reviewer.sessionId = progress.sessionId;
+            reviewer.status = "running";
+            reviewer.lastUpdate = now();
+            this.sessionToRun.set(progress.sessionId, {
+                agent: progress.reviewer,
+                runId,
+            });
+        }
+        if (progress.type === "reviewer_repair") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.status = "repairing";
+            reviewer.repairAttempts += 1;
+            reviewer.lastUpdate = now();
+        }
+        if (progress.type === "reviewer_response") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.sessionId = progress.sessionId;
+            reviewer.lastUpdate = now();
+        }
+        if (progress.type === "reviewer_failed") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.status = "failed";
+            reviewer.error = progress.error;
+            reviewer.lastUpdate = now();
+        }
+        if (progress.type === "reviewer_completed") {
+            const reviewer = state.reviewers[progress.reviewer];
+            if (!reviewer)
+                return;
+            reviewer.sessionId = progress.sessionId;
+            reviewer.status = "completed";
+            reviewer.verdict = progress.verdict;
+            reviewer.lastUpdate = now();
+        }
+        if (progress.type === "completed") {
+            state.verdict = progress.verdict;
+        }
+        await this.persist(state);
+        if (progress.type === "reviewer_reconsidered") {
+            await this.notify(state, closeReconsiderationText({
+                pr: prMarkdownLink(state),
+                reviewer: progress.reviewer,
+                to: progress.to,
+            }));
+        }
+        if (progress.type === "findings_validated") {
+            await this.notify(state, findingsValidationText({
+                discarded: progress.discarded,
+                kept: progress.kept,
+                pr: prMarkdownLink(state),
+            }));
+            for (const reviewer of progress.reviewersChangedToMerge) {
+                await this.notify(state, `**Reviewer ${reviewer}** had no remaining findings after validation and approved ${prMarkdownLink(state)}.`);
+            }
+        }
+        if (progress.type === "ci_report") {
+            await this.notify(state, ciReportText({ pr: prMarkdownLink(state), report: progress.report }));
+        }
+        if (progress.type === "ci_classifier_started") {
+            await this.notify(state, `**CI classifier ${progress.reviewer}** started for ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "ci_classifier_repair") {
+            await this.notify(state, `**CI classifier ${progress.reviewer}** started JSON regeneration for ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "ci_classifier_completed") {
+            await this.notify(state, `**CI classifier ${progress.reviewer}** completed for ${prMarkdownLink(state)}: ${progress.classification} - ${progress.reason}`);
+        }
+        if (progress.type === "ci_classifier_failed") {
+            await this.notify(state, `**CI classifier ${progress.reviewer}** failed for ${prMarkdownLink(state)}: ${progress.error}`);
+        }
+        if (progress.type === "worktree_created") {
+            await this.notify(state, `Worktree is ready for ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "reviewer_started") {
+            await this.notify(state, `**Reviewer ${progress.reviewer}** started reviewing ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "reviewer_skipped") {
+            await this.notify(state, `**Reviewer ${progress.reviewer}** skipped ${prMarkdownLink(state)} with existing verdict ${progress.verdict}.`);
+        }
+        if (progress.type === "reviewer_repair") {
+            await this.notify(state, `**Reviewer ${progress.reviewer}** started JSON regeneration for ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "reviewer_failed") {
+            await this.notify(state, reviewerFailureText({
+                error: progress.error,
+                pr: prMarkdownLink(state),
+                repairAttempts: state.reviewers[progress.reviewer]?.repairAttempts ?? 0,
+                reviewer: progress.reviewer,
+            }));
+        }
+        if (progress.type === "phase" && state.command === "review") {
+            const text = mergePhaseText({
+                phase: progress.phase,
+                pr: prMarkdownLink(state),
+            });
+            if (text)
+                await this.notify(state, text);
+        }
+        if (progress.type === "completed" && state.command === "merge") {
+            await this.notify(state, reviewDecisionText({
+                pr: prMarkdownLink(state),
+                verdict: progress.verdict,
+            }));
+        }
+        if (progress.type === "completed" && state.command === "review") {
+            await this.notify(state, reviewDecisionText({
+                pr: prMarkdownLink(state),
+                verdict: progress.verdict,
+            }));
+        }
+        if (progress.type === "reviewer_completed") {
+            await this.notify(state, reviewerCompletionText({
+                pr: prMarkdownLink(state),
+                reviewer: progress.reviewer,
+                verdict: progress.verdict,
+            }));
+        }
+    }
+    async applyMergeProgress(runId, progress) {
+        if (progress.type === "phase" ||
+            progress.type === "worktree_created" ||
+            progress.type === "reviewer_started" ||
+            progress.type === "reviewer_skipped" ||
+            progress.type === "reviewer_session" ||
+            progress.type === "reviewer_repair" ||
+            progress.type === "reviewer_response" ||
+            progress.type === "reviewer_failed" ||
+            progress.type === "reviewer_completed" ||
+            progress.type === "reviewer_reconsidered" ||
+            progress.type === "findings_validated" ||
+            progress.type === "ci_report" ||
+            progress.type === "completed") {
+            if (progress.type === "phase") {
+                const state = this.active.get(runId);
+                const text = state
+                    ? mergePhaseText({ phase: progress.phase, pr: prMarkdownLink(state) })
+                    : undefined;
+                if (state && text)
+                    await this.notify(state, text);
+            }
+            await this.applyReviewProgress(runId, progress);
+            return;
+        }
+        const state = this.active.get(runId);
+        if (!state)
+            return;
+        if (progress.type === "warning") {
+            state.warnings = [...(state.warnings ?? []), progress.message];
+            await this.persist(state);
+            await this.notify(state, `Warning for ${prMarkdownLink(state)}: ${progress.message}`);
+            return;
+        }
+        if (progress.type === "thread_limit_reached") {
+            await this.notify(state, threadLimitText({
+                pr: prMarkdownLink(state),
+                threads: progress.threads,
+            }));
+            return;
+        }
+        if (progress.type === "thread_attempts") {
+            state.threadAttempts = progress.attempts;
+            await this.persist(state);
+            await this.notify(state, `Tracked ${Object.keys(progress.attempts).length} review thread resolution attempts for ${prMarkdownLink(state)}.`);
+            return;
+        }
+        const editor = state.editor;
+        if (!editor)
+            return;
+        state.updatedAt = now();
+        if (progress.type === "editor_started") {
+            editor.status = "running";
+        }
+        if (progress.type === "editor_session") {
+            if (progress.options)
+                this.input.setSessionOptions?.(progress.sessionId, progress.options);
+            editor.sessionId = progress.sessionId;
+            editor.status = "running";
+            editor.lastUpdate = now();
+            this.sessionToRun.set(progress.sessionId, { agent: "editor", runId });
+        }
+        if (progress.type === "editor_repair") {
+            editor.status = "repairing";
+            editor.repairAttempts += 1;
+            editor.lastUpdate = now();
+        }
+        if (progress.type === "editor_response") {
+            editor.sessionId = progress.sessionId;
+            editor.lastUpdate = now();
+        }
+        if (progress.type === "editor_failed") {
+            editor.status = "failed";
+            editor.error = progress.error;
+            editor.lastUpdate = now();
+        }
+        if (progress.type === "editor_completed") {
+            editor.status = "completed";
+            editor.rawPath = join(state.outputDir, `editor.cycle-${progress.cycle}.raw.txt`);
+            editor.parsedPath = join(state.outputDir, `editor.cycle-${progress.cycle}.json`);
+            editor.lastUpdate = now();
+        }
+        if (progress.type === "merge_completed") {
+            state.verdict = progress.status;
+        }
+        await this.persist(state);
+        if (progress.type === "editor_started") {
+            await this.notify(state, `**Editor** started edit cycle ${progress.cycle} for ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "editor_repair") {
+            await this.notify(state, `**Editor** started JSON regeneration for ${prMarkdownLink(state)} cycle ${progress.cycle}.`);
+        }
+        if (progress.type === "editor_completed") {
+            await this.notify(state, `**Editor** finished editing ${prMarkdownLink(state)}.`);
+        }
+        if (progress.type === "editor_failed") {
+            await this.notify(state, editorFailureText({
+                error: progress.error,
+                pr: prMarkdownLink(state),
+                repairAttempts: state.editor?.repairAttempts ?? 0,
+            }));
+        }
+        if (progress.type === "merge_completed") {
+            await this.notify(state, `Merge workflow reached ${progress.status} for ${prMarkdownLink(state)}.`);
+        }
+    }
+    async failRun(runId, error) {
+        const state = this.active.get(runId);
+        if (!state)
+            return;
+        if (state.status === "cancelled")
+            return;
+        state.status = "failed";
+        state.phase = "failed";
+        state.completedAt = now();
+        state.error = error instanceof Error ? error.message : String(error);
+        if (state.editor?.status === "pending" ||
+            state.editor?.status === "running" ||
+            state.editor?.status === "repairing" ||
+            state.editor?.status === "blocked") {
+            state.editor.status = "failed";
+            state.editor.error = state.error;
+        }
+        if (state.editor?.sessionId) {
+            await this.input.client.session
+                .abort?.({ path: { id: state.editor.sessionId } })
+                .catch(() => undefined);
+        }
+        for (const reviewer of Object.values(state.reviewers)) {
+            if (reviewer.status === "pending" ||
+                reviewer.status === "running" ||
+                reviewer.status === "repairing" ||
+                reviewer.status === "blocked") {
+                reviewer.status = "failed";
+                reviewer.error = state.error;
+            }
+            if (reviewer.sessionId) {
+                await this.input.client.session
+                    .abort?.({ path: { id: reviewer.sessionId } })
+                    .catch(() => undefined);
+            }
+        }
+        for (const classifier of Object.values(state.ciClassifiers ?? {})) {
+            if (classifier.status === "pending" ||
+                classifier.status === "running" ||
+                classifier.status === "repairing" ||
+                classifier.status === "blocked") {
+                classifier.status = "failed";
+                classifier.error = state.error;
+            }
+            if (classifier.sessionId) {
+                await this.input.client.session
+                    .abort?.({ path: { id: classifier.sessionId } })
+                    .catch(() => undefined);
+            }
+        }
+        await this.persist(state);
+        await this.notify(state, `Magi ${state.command} failed for ${runLabel(state)}: ${state.error}`, { reply: true });
+        this.active.delete(runId);
+        this.controllers.delete(runId);
+    }
+    async filteredStates(input) {
+        const states = input.runId
+            ? (await this.readStateByRunId(input.runId))
+                ? [(await this.readStateByRunId(input.runId))]
+                : []
+            : await this.listStates(input.outputDir);
+        return states
+            .filter((state) => input.command == null || state.command === input.command)
+            .filter((state) => input.pr == null || state.pr === input.pr)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async selectState(input) {
+        if (input.runId)
+            return this.readStateByRunId(input.runId);
+        return (await this.filteredStates(input))[0];
+    }
+    selectorText(input) {
+        if (input.runId)
+            return input.runId;
+        if (input.pr != null)
+            return `PR #${input.pr}`;
+        return "all runs";
+    }
+    absoluteOutputDir(dir) {
+        return isAbsolute(dir) ? dir : join(this.input.directory, dir);
+    }
+    absoluteWorktreeDirs(input) {
+        const worktreeDirs = Array.isArray(input.worktreeDir)
+            ? input.worktreeDir
+            : input.worktreeDir
+                ? [input.worktreeDir]
+                : worktreeBaseDirs(this.input.directory);
+        return worktreeDirs.map((dir) => isAbsolute(dir) ? dir : join(this.input.directory, dir));
+    }
+    emptyOutputCleanupRoots(input) {
+        const outputDirs = Array.isArray(input.outputDir)
+            ? input.outputDir
+            : input.outputDir
+                ? [input.outputDir]
+                : [join(this.input.directory, ".magi", "runs")];
+        return outputDirs.map((dir) => this.absoluteOutputDir(dir));
+    }
+    async pruneEmptyMagiDirectories(input) {
+        for (const dir of input.trees) {
+            await pruneEmptyDirectories({
+                boundary: this.input.directory,
+                recursive: true,
+                start: dir,
+            });
+        }
+        for (const dir of input.dirs) {
+            await pruneEmptyDirectories({
+                boundary: this.input.directory,
+                start: dir,
+            });
+        }
+    }
+    async listStates(outputDir) {
+        for (const dir of Array.isArray(outputDir)
+            ? outputDir
+            : outputDir
+                ? [outputDir]
+                : []) {
+            this.outputDirs.add(this.absoluteOutputDir(dir));
+        }
+        const baseDirs = [...this.outputDirs].map((dir) => this.absoluteOutputDir(dir));
+        if (!baseDirs.length)
+            baseDirs.push(join(this.input.directory, ".magi", "runs"));
+        const states = [];
+        async function walk(dir) {
+            const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(path);
+                    continue;
+                }
+                if (entry.name !== "state.json")
+                    continue;
+                const state = await readFile(path, "utf8")
+                    .then((text) => JSON.parse(text))
+                    .catch(() => undefined);
+                if (state)
+                    states.push(state);
+            }
+        }
+        for (const baseDir of baseDirs)
+            await walk(baseDir);
+        for (const state of this.active.values()) {
+            if (!states.some((item) => item.runId === state.runId))
+                states.push(state);
+        }
+        return states;
+    }
+    async readStateByRunId(runId) {
+        const active = this.active.get(runId);
+        if (active)
+            return active;
+        const knownPath = this.runPaths.get(runId);
+        if (knownPath) {
+            const state = await readFile(knownPath, "utf8")
+                .then((text) => JSON.parse(text))
+                .catch(() => undefined);
+            if (state)
+                return state;
+        }
+        return (await this.listStates()).find((state) => state.runId === runId);
+    }
+    async persist(state) {
+        state.updatedAt = now();
+        await mkdir(state.outputDir, { recursive: true });
+        const path = join(state.outputDir, "state.json");
+        this.runPaths.set(state.runId, path);
+        await writeFile(path, `${JSON.stringify(state, null, 2)}\n`);
+    }
+    async notify(state, text, options = {}) {
+        if (!state.parentSessionId || !this.input.client.session.promptAsync)
+            return;
+        void options;
+        await this.input.client.session
+            .promptAsync({
+            body: {
+                parts: [{ type: "text", text, synthetic: true }],
+            },
+            path: { id: state.parentSessionId },
+        })
+            .catch(() => undefined);
+    }
+}