@backburner/cli 0.1.0

package/dist/src/agents/antigravity.js

@@ -0,0 +1,251 @@
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writeJsonFileAtomic } from "../utils/json.js";
+import { buildAntigravityCliArgs, ensureAntigravityMcpConfig, getAntigravityEnvOverrides, mapPermissionToAntigravityMode, prependGlobalAntigravityLaunchInstructions, writeAntigravityMcpConfig, writeAntigravitySettings } from "./antigravity-launch.js";
+import { buildExecutionId, extractAndExportPlanBreakdownResult, extractAndExportWaveAssessmentResult, extractExitCode, extractReviewResult, extractStderr, extractStdout, extractTriageResult, detectProviderLimit } from "./extraction.js";
+import { buildPromptPacket, renderPrompt } from "./prompt.js";
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+const DEFAULT_PRINT_TIMEOUT = "20m";
+export class AntigravityCliAgent {
+    options;
+    now;
+    timeoutMs;
+    printTimeout;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.printTimeout = options.printTimeout ?? DEFAULT_PRINT_TIMEOUT;
+        this.logger = options.logger;
+    }
+    async dispatch(task, context, agentConfig, _sessionDecision, promptContent) {
+        const promptPacket = buildPromptPacket(task, context);
+        const promptText = prependGlobalAntigravityLaunchInstructions(renderPrompt(task, promptPacket, {
+            providerIdentity: "Antigravity CLI",
+            customConstraints: promptContent?.content,
+            learningOverlays: promptContent?.learningOverlays
+        }), { ...(this.options.githubBroker ? { mcp: this.options.githubBroker } : {}) });
+        const startedAt = this.now();
+        const executionId = buildExecutionId(task.id, startedAt);
+        const artifactDir = path.join(this.options.logDir, "artifacts", executionId);
+        const promptPacketPath = path.join(artifactDir, "prompt-packet.json");
+        const promptArtifactPath = path.join(artifactDir, "prompt.md");
+        const stdoutArtifactPath = path.join(artifactDir, "stdout.txt");
+        const stderrArtifactPath = path.join(artifactDir, "stderr.txt");
+        const streamArtifactPath = path.join(artifactDir, "stdout-raw.txt");
+        const settingsArtifactPath = path.join(artifactDir, "antigravity-settings.json");
+        const mcpConfigArtifactPath = path.join(artifactDir, "antigravity-mcp-config.json");
+        const logFilePath = path.join(artifactDir, "antigravity.log");
+        const antigravityHome = this.options.configHome ?? path.join(os.homedir(), ".gemini", "antigravity-cli");
+        const legacyGeminiConfigHome = this.options.legacyGeminiConfigHome ??
+            (this.options.configHome ? undefined : path.join(os.homedir(), ".gemini", "config"));
+        const cwd = context.localRepoPath ?? process.cwd();
+        const permissionMode = mapPermissionToAntigravityMode(task.executionPermission);
+        const resumeConversationId = _sessionDecision?.mode === "native_resume_candidate"
+            ? _sessionDecision.record.providerSessionId
+            : undefined;
+        await mkdir(artifactDir, { recursive: true });
+        await Promise.all([
+            writeJsonFileAtomic(promptPacketPath, promptPacket),
+            writeFile(promptArtifactPath, promptText, "utf8"),
+            writeAntigravitySettings(settingsArtifactPath, {
+                permissionMode,
+                cwd,
+                ...(agentConfig.model ? { model: agentConfig.model } : {})
+            }),
+            writeAntigravityMcpConfig(mcpConfigArtifactPath, {
+                ...(this.options.githubBroker ? { mcp: this.options.githubBroker } : {})
+            })
+        ]);
+        const args = buildAntigravityCliArgs({
+            permissionMode,
+            ...(agentConfig.model ? { model: agentConfig.model } : {}),
+            ...(resumeConversationId ? { conversationId: resumeConversationId } : {}),
+            printTimeout: this.printTimeout,
+            logFilePath
+        });
+        this.logger?.info(JSON.stringify({
+            component: "antigravity-launch",
+            taskKind: task.kind,
+            targetRepoPath: cwd,
+            antigravityHome,
+            settingsPath: settingsArtifactPath,
+            mcpConfigPath: mcpConfigArtifactPath,
+            legacyGeminiMcpConfigPath: legacyGeminiConfigHome
+                ? path.join(legacyGeminiConfigHome, "mcp_config.json")
+                : undefined,
+            mcpServerUrl: this.options.githubBroker?.serverUrl
+        }));
+        let exitCode = 0;
+        let rawStdout = "";
+        let rawStderr = "";
+        try {
+            if (this.options.githubBroker) {
+                const setup = await ensureAntigravityMcpConfig(antigravityHome, this.options.githubBroker);
+                this.logger?.info(JSON.stringify({
+                    component: "antigravity-mcp-bootstrap",
+                    configPath: setup.configPath,
+                    changed: setup.changed,
+                    backupPath: setup.backupPath
+                }));
+                if (legacyGeminiConfigHome) {
+                    const legacySetup = await ensureAntigravityMcpConfig(legacyGeminiConfigHome, this.options.githubBroker);
+                    this.logger?.info(JSON.stringify({
+                        component: "antigravity-legacy-gemini-mcp-bootstrap",
+                        configPath: legacySetup.configPath,
+                        changed: legacySetup.changed,
+                        backupPath: legacySetup.backupPath
+                    }));
+                }
+            }
+            const result = await this.options.commandRunner.run(agentConfig.command, args, {
+                cwd,
+                input: promptText,
+                env: getAntigravityEnvOverrides(),
+                timeoutMs: this.timeoutMs
+            });
+            exitCode = result.exitCode;
+            rawStdout = result.stdout;
+            rawStderr = result.stderr;
+        }
+        catch (error) {
+            exitCode = extractExitCode(error);
+            rawStdout = extractStdout(error);
+            rawStderr = extractStderr(error) || (error instanceof Error ? error.message : String(error));
+        }
+        const stdout = normalizeAntigravityStdout(rawStdout);
+        const endedAt = this.now();
+        const observedConversationId = await readAntigravityConversationIdForCwd(antigravityHome, cwd)
+            .catch((err) => {
+            this.logger?.warn(`[antigravity-session] Failed to read conversation id for ${cwd}: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        });
+        const finalConversationId = observedConversationId ?? resumeConversationId;
+        await Promise.all([
+            writeFile(streamArtifactPath, rawStdout, "utf8"),
+            writeFile(stdoutArtifactPath, stdout, "utf8"),
+            writeFile(stderrArtifactPath, rawStderr, "utf8")
+        ]);
+        const triageResult = extractTriageResult(task, stdout);
+        const reviewResult = extractReviewResult(task, stdout);
+        const planBreakdownExtraction = extractAndExportPlanBreakdownResult(task, stdout, this.options.planBreakdownSessionStore);
+        const waveAssessmentExtraction = extractAndExportWaveAssessmentResult(task, stdout, this.options.waveAssessmentSessionStore);
+        let taskStatus = exitCode === 0 ? "completed" : "failed";
+        let errorMessage = exitCode === 0 ? undefined : rawStderr.trim() || "Antigravity CLI exited with a non-zero status.";
+        if (task.kind === "review_pr" && exitCode === 0 && !reviewResult) {
+            taskStatus = "failed";
+            errorMessage = "Agent output did not contain a valid structured review result.";
+        }
+        if ((task.kind === "plan_breakdown" || task.kind === "wave_plan_replanning") &&
+            exitCode === 0 &&
+            !planBreakdownExtraction.ok) {
+            taskStatus = "failed";
+            errorMessage = planBreakdownExtraction.message;
+        }
+        if (task.kind === "wave_plan_assessment" && exitCode === 0 && !waveAssessmentExtraction.ok) {
+            taskStatus = "failed";
+            errorMessage = waveAssessmentExtraction.message;
+        }
+        const execution = {
+            id: executionId,
+            taskId: task.id,
+            taskKind: task.kind,
+            taskStatus,
+            repoId: task.repoId,
+            repoSlug: task.repoSlug,
+            agentId: agentConfig.id,
+            agentProvider: "antigravity",
+            ...(agentConfig.model ? { agentModel: agentConfig.model } : {}),
+            command: {
+                executable: agentConfig.command,
+                args,
+                cwd,
+                timeoutMs: this.timeoutMs
+            },
+            promptArtifactPath,
+            stdoutArtifactPath,
+            stderrArtifactPath,
+            streamArtifactPath,
+            promptPacketPath,
+            settingsArtifactPath,
+            startedAt,
+            endedAt,
+            exitCode,
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(triageResult || reviewResult || planBreakdownExtraction.ok || waveAssessmentExtraction.ok
+                ? {
+                    result: {
+                        ...(triageResult ? { triage: triageResult } : {}),
+                        ...(reviewResult ? { review: reviewResult } : {}),
+                        ...(planBreakdownExtraction.ok
+                            ? {
+                                planBreakdown: planBreakdownExtraction.planBreakdown,
+                                planBreakdownSessionId: planBreakdownExtraction.sessionId
+                            }
+                            : {}),
+                        ...(waveAssessmentExtraction.ok
+                            ? {
+                                waveAssessment: waveAssessmentExtraction.waveAssessment
+                            }
+                            : {})
+                    }
+                }
+                : {})
+        };
+        const providerLimitSignal = detectProviderLimit("antigravity", exitCode, rawStdout, rawStderr);
+        return {
+            taskStatus: execution.taskStatus,
+            execution,
+            ...(providerLimitSignal ? { providerLimitSignal } : {}),
+            ...(finalConversationId
+                ? {
+                    providerSession: {
+                        providerSessionId: finalConversationId,
+                        status: "active"
+                    }
+                }
+                : {})
+        };
+    }
+}
+export function normalizeAntigravityStdout(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .filter((line) => line.trim() !== "--print-timeout")
+        .join("\n")
+        .trimEnd();
+}
+export async function readAntigravityConversationIdForCwd(antigravityHome, cwd) {
+    const cachePath = path.join(antigravityHome, "cache", "last_conversations.json");
+    let raw;
+    try {
+        raw = await readFile(cachePath, "utf8");
+    }
+    catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+            return undefined;
+        }
+        throw err;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const conversations = parsed;
+    const candidates = new Set([cwd]);
+    try {
+        candidates.add(await realpath(cwd));
+    }
+    catch {
+        // The cwd may have been removed after the run; fall back to the literal path.
+    }
+    for (const candidate of candidates) {
+        const value = conversations[candidate];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}

package/dist/src/agents/claude-launch.js

@@ -0,0 +1,117 @@
+import * as fs from "node:fs/promises";
+/**
+ * Maps orchestrator permissions to Claude Code CLI permission modes.
+ * - read-only -> dontAsk
+ * - workspace-write -> bypassPermissions (allows running local bash commands like npm, docker-compose)
+ */
+export function mapPermissionToClaudePermissionMode(permission) {
+    return permission === "workspace-write" ? "bypassPermissions" : "dontAsk";
+}
+/**
+ * Builds CLI arguments for Claude Code CLI.
+ * Uses -p for print mode (non-interactive).
+ */
+export function buildClaudeCliArgs(options) {
+    const args = ["-p", "--permission-mode", options.permissionMode];
+    if (options.resumeSessionId) {
+        args.push("--resume", options.resumeSessionId);
+    }
+    else if (options.plannedSessionId) {
+        args.push("--session-id", options.plannedSessionId);
+        if (options.sessionName) {
+            args.push("--name", options.sessionName);
+        }
+    }
+    if (options.model) {
+        args.push("--model", options.model);
+    }
+    if (options.settingsPath) {
+        args.push("--settings", options.settingsPath);
+    }
+    if (options.mcpConfigPath) {
+        args.push("--mcp-config", options.mcpConfigPath, "--strict-mcp-config");
+    }
+    if (options.allowedTools && options.allowedTools.length > 0) {
+        args.push("--allowedTools", options.allowedTools.join(","));
+    }
+    return args;
+}
+/**
+ * Builds the MCP configuration object for Claude.
+ */
+export function buildClaudeMcpConfig(mcp) {
+    return {
+        mcpServers: {
+            [mcp.serverName]: {
+                type: "http",
+                url: mcp.serverUrl
+            }
+        }
+    };
+}
+/**
+ * Builds the settings configuration object for Claude.
+ */
+export function buildClaudeSettings(options) {
+    if (options.workspacePath) {
+        return { trustedWorkspaces: [options.workspacePath] };
+    }
+    return {};
+}
+/**
+ * Writes the MCP configuration to a file.
+ */
+export async function writeClaudeMcpConfig(path, mcp) {
+    const config = buildClaudeMcpConfig(mcp);
+    await fs.writeFile(path, JSON.stringify(config, null, 2));
+}
+/**
+ * Writes the settings configuration to a file.
+ */
+export async function writeClaudeSettings(path, options) {
+    const settings = buildClaudeSettings(options);
+    await fs.writeFile(path, JSON.stringify(settings, null, 2));
+}
+/**
+ * Generates the allow-list of tool names for Claude's --allowedTools flag.
+ * Names follow the mcp__<serverName>__<toolName> pattern.
+ */
+export function buildClaudeAllowedTools(mcp) {
+    return mcp.toolAllowList.map((tool) => {
+        const normalizedToolName = tool.replaceAll(".", "_");
+        return `mcp__${mcp.serverName}__${normalizedToolName}`;
+    });
+}
+/**
+ * Provides global launch instructions for Claude agents.
+ */
+export function buildGlobalClaudeLaunchInstructions(input) {
+    const tools = buildClaudeAllowedTools(input.mcp).join(", ");
+    return `
+# Claude Code CLI Launch Instructions
+
+You are running inside a managed orchestrator.
+A local MCP server named "${input.mcp.serverName}" is available and pre-authorized.
+The following tools are allowed: ${tools}.
+
+## Operational Rules
+
+1. Use the local MCP server for all GitHub operations (issues, PRs, comments, code search).
+2. Do not use the "gh" CLI or other external GitHub tools directly for these tasks.
+3. If a required GitHub capability is missing from the MCP server, report it as a limitation rather than attempting a bypass.
+4. Adhere to the repository-local AGENTS.md instructions if present.
+5. Any message you post to GitHub (via comments or PR descriptions) MUST begin with the "🤖" emoji.
+
+Ready for task execution.
+`.trim();
+}
+/**
+ * Prepends global instructions to a prompt if MCP is configured.
+ */
+export function prependGlobalClaudeLaunchInstructions(promptText, options) {
+    if (!options.mcp) {
+        return promptText;
+    }
+    const instructions = buildGlobalClaudeLaunchInstructions({ mcp: options.mcp });
+    return `${instructions}\n\n${promptText}`;
+}

package/dist/src/agents/claude.js

@@ -0,0 +1,271 @@
+import { copyFile, mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writeJsonFileAtomic } from "../utils/json.js";
+import { buildClaudeAllowedTools, buildClaudeCliArgs, mapPermissionToClaudePermissionMode, prependGlobalClaudeLaunchInstructions, writeClaudeMcpConfig, writeClaudeSettings } from "./claude-launch.js";
+import { buildExecutionId, extractExitCode, extractAndExportPlanBreakdownResult, extractAndExportWaveAssessmentResult, extractReviewResult, extractStderr, extractStdout, extractTriageResult, detectProviderLimit } from "./extraction.js";
+import { buildPromptPacket, renderPrompt } from "./prompt.js";
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+export class ClaudeCodeCliAgent {
+    options;
+    now;
+    timeoutMs;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.logger = options.logger;
+    }
+    async dispatch(task, context, agentConfig, sessionDecision, promptContent) {
+        const promptPacket = buildPromptPacket(task, context);
+        const promptText = prependGlobalClaudeLaunchInstructions(renderPrompt(task, promptPacket, {
+            providerIdentity: "Claude Code CLI",
+            customConstraints: promptContent?.content,
+            learningOverlays: promptContent?.learningOverlays
+        }), { ...(this.options.githubBroker ? { mcp: this.options.githubBroker } : {}) });
+        const startedAt = this.now();
+        const executionId = buildExecutionId(task.id, startedAt);
+        const artifactDir = path.join(this.options.logDir, "artifacts", executionId);
+        const promptPacketPath = path.join(artifactDir, "prompt-packet.json");
+        const promptArtifactPath = path.join(artifactDir, "prompt.md");
+        const stdoutArtifactPath = path.join(artifactDir, "stdout.txt");
+        const stderrArtifactPath = path.join(artifactDir, "stderr.txt");
+        const providerTranscriptArtifactPath = path.join(artifactDir, "claude-project-transcript.jsonl");
+        const mcpConfigPath = path.join(artifactDir, "claude-mcp-config.json");
+        const settingsArtifactPath = path.join(artifactDir, "claude-settings.json");
+        await mkdir(artifactDir, { recursive: true });
+        const cwd = context.localRepoPath ?? process.cwd();
+        const writeTasks = [
+            writeJsonFileAtomic(promptPacketPath, promptPacket),
+            writeFile(promptArtifactPath, promptText, "utf8")
+        ];
+        if (this.options.githubBroker) {
+            writeTasks.push(writeClaudeMcpConfig(mcpConfigPath, this.options.githubBroker));
+            writeTasks.push(writeClaudeSettings(settingsArtifactPath, {
+                mcp: this.options.githubBroker,
+                workspacePath: cwd
+            }));
+        }
+        await Promise.all(writeTasks);
+        const permissionMode = mapPermissionToClaudePermissionMode(task.executionPermission);
+        const resumeSessionId = sessionDecision?.mode === "native_resume_candidate"
+            ? sessionDecision.record.providerSessionId
+            : undefined;
+        const plannedSessionId = sessionDecision?.mode === "new_session"
+            ? sessionDecision.providerSessionId
+            : undefined;
+        const sessionName = sessionDecision?.mode === "new_session"
+            ? sessionDecision.providerSessionName
+            : undefined;
+        const args = buildClaudeCliArgs({
+            permissionMode,
+            resumeSessionId,
+            plannedSessionId,
+            sessionName,
+            ...(agentConfig.model ? { model: agentConfig.model } : {}),
+            ...(this.options.githubBroker
+                ? {
+                    mcpConfigPath,
+                    settingsPath: settingsArtifactPath,
+                    allowedTools: buildClaudeAllowedTools(this.options.githubBroker)
+                }
+                : {})
+        });
+        this.logger?.info(JSON.stringify({
+            component: "claude-launch",
+            taskKind: task.kind,
+            targetRepoPath: cwd,
+            mcpConfigPath: this.options.githubBroker ? mcpConfigPath : undefined,
+            mcpServerUrl: this.options.githubBroker?.serverUrl
+        }));
+        let exitCode = 0;
+        let stdout = "";
+        let stderr = "";
+        try {
+            const result = await this.options.commandRunner.run(agentConfig.command, args, {
+                cwd,
+                input: promptText,
+                timeoutMs: this.timeoutMs
+            });
+            exitCode = result.exitCode;
+            stdout = result.stdout;
+            stderr = result.stderr;
+        }
+        catch (error) {
+            exitCode = extractExitCode(error);
+            stdout = extractStdout(error);
+            stderr = extractStderr(error);
+        }
+        const endedAt = this.now();
+        const originalStderr = stderr;
+        const transcriptCapture = await captureClaudeProjectTranscript({
+            cwd,
+            startedAt,
+            artifactPath: providerTranscriptArtifactPath,
+            ...(this.options.claudeProjectsDir ? { projectsDir: this.options.claudeProjectsDir } : {}),
+            ...(this.logger ? { logger: this.logger } : {})
+        });
+        if (transcriptCapture && exitCode !== 0 && stderr.trim() === "") {
+            stderr = [
+                `Claude project transcript captured at ${providerTranscriptArtifactPath}`,
+                `Source: ${transcriptCapture.sourcePath}`
+            ].join("\n");
+        }
+        await Promise.all([
+            writeFile(stdoutArtifactPath, stdout, "utf8"),
+            writeFile(stderrArtifactPath, stderr, "utf8")
+        ]);
+        const triageResult = extractTriageResult(task, stdout);
+        const reviewResult = extractReviewResult(task, stdout);
+        const planBreakdownExtraction = extractAndExportPlanBreakdownResult(task, stdout, this.options.planBreakdownSessionStore);
+        const waveAssessmentExtraction = extractAndExportWaveAssessmentResult(task, stdout, this.options.waveAssessmentSessionStore);
+        let taskStatus = exitCode === 0 ? "completed" : "failed";
+        let errorMessage = exitCode === 0 ? undefined : originalStderr.trim() || "Claude Code CLI exited with a non-zero status.";
+        if (task.kind === "review_pr" && exitCode === 0 && !reviewResult) {
+            taskStatus = "failed";
+            errorMessage = "Agent output did not contain a valid structured review result.";
+        }
+        if ((task.kind === "plan_breakdown" || task.kind === "wave_plan_replanning") && exitCode === 0) {
+            if (!planBreakdownExtraction.ok) {
+                taskStatus = "failed";
+                errorMessage = planBreakdownExtraction.message;
+            }
+        }
+        if (task.kind === "wave_plan_assessment" && exitCode === 0) {
+            if (!waveAssessmentExtraction.ok) {
+                taskStatus = "failed";
+                errorMessage = waveAssessmentExtraction.message;
+            }
+        }
+        const execution = {
+            id: executionId,
+            taskId: task.id,
+            taskKind: task.kind,
+            taskStatus,
+            repoId: task.repoId,
+            repoSlug: task.repoSlug,
+            agentId: agentConfig.id,
+            agentProvider: "claude",
+            ...(agentConfig.model ? { agentModel: agentConfig.model } : {}),
+            command: {
+                executable: agentConfig.command,
+                args,
+                cwd,
+                timeoutMs: this.timeoutMs
+            },
+            promptArtifactPath,
+            stdoutArtifactPath,
+            stderrArtifactPath,
+            ...(transcriptCapture ? { providerTranscriptArtifactPath } : {}),
+            promptPacketPath,
+            ...(this.options.githubBroker ? { settingsArtifactPath } : {}),
+            startedAt,
+            endedAt,
+            exitCode,
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(triageResult || reviewResult || planBreakdownExtraction.ok || waveAssessmentExtraction.ok
+                ? {
+                    result: {
+                        ...(triageResult ? { triage: triageResult } : {}),
+                        ...(reviewResult ? { review: reviewResult } : {}),
+                        ...(planBreakdownExtraction.ok
+                            ? {
+                                planBreakdown: planBreakdownExtraction.planBreakdown,
+                                planBreakdownSessionId: planBreakdownExtraction.sessionId
+                            }
+                            : {}),
+                        ...(waveAssessmentExtraction.ok
+                            ? {
+                                waveAssessment: waveAssessmentExtraction.waveAssessment
+                            }
+                            : {})
+                    }
+                }
+                : {})
+        };
+        const parsedSessionId = extractSessionIdFromClaudeOutput(stdout);
+        const finalSessionId = parsedSessionId || plannedSessionId || resumeSessionId;
+        const finalSessionName = parsedSessionId ? undefined : (sessionName || (sessionDecision?.mode === "native_resume_candidate" ? sessionDecision.record.providerSessionName : undefined));
+        const providerLimitSignal = detectProviderLimit("claude", exitCode, stdout, stderr);
+        return {
+            taskStatus: execution.taskStatus,
+            execution,
+            ...(providerLimitSignal ? { providerLimitSignal } : {}),
+            ...(finalSessionId
+                ? {
+                    providerSession: {
+                        providerSessionId: finalSessionId,
+                        status: "active",
+                        ...(finalSessionName ? { providerSessionName: finalSessionName } : {})
+                    }
+                }
+                : {})
+        };
+    }
+}
+async function captureClaudeProjectTranscript(input) {
+    const projectsDir = input.projectsDir ?? path.join(os.homedir(), ".claude", "projects");
+    const projectDir = path.join(projectsDir, encodeClaudeProjectPath(input.cwd));
+    const startedAtMs = Date.parse(input.startedAt);
+    const minMtimeMs = Number.isFinite(startedAtMs) ? startedAtMs - 5_000 : 0;
+    try {
+        const entries = await readdir(projectDir, { withFileTypes: true });
+        const candidates = [];
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+                continue;
+            }
+            const filePath = path.join(projectDir, entry.name);
+            const fileStat = await stat(filePath);
+            if (fileStat.mtimeMs >= minMtimeMs) {
+                candidates.push({ filePath, mtimeMs: fileStat.mtimeMs });
+            }
+        }
+        candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        const latest = candidates[0];
+        if (!latest) {
+            return undefined;
+        }
+        await copyFile(latest.filePath, input.artifactPath);
+        return { sourcePath: latest.filePath };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            input.logger?.warn(`[claude-transcript] Failed to capture Claude project transcript for ${input.cwd}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return undefined;
+    }
+}
+function encodeClaudeProjectPath(cwd) {
+    return path.resolve(cwd).replace(/[^A-Za-z0-9]/g, "-");
+}
+function extractSessionIdFromClaudeOutput(stdoutText) {
+    if (!stdoutText.trim()) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(stdoutText);
+        if (parsed && typeof parsed === "object" && typeof parsed.session_id === "string") {
+            return parsed.session_id;
+        }
+    }
+    catch {
+        // Substring parse candidate
+        const start = stdoutText.indexOf("{");
+        const end = stdoutText.lastIndexOf("}");
+        if (start !== -1 && end !== -1 && end > start) {
+            try {
+                const parsed = JSON.parse(stdoutText.substring(start, end + 1));
+                if (parsed && typeof parsed === "object" && typeof parsed.session_id === "string") {
+                    return parsed.session_id;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return undefined;
+}