@junctionpanel/server 0.1.24 → 0.1.26

package/dist/server/server/worktree-bootstrap.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from "pino";
+import type { BootstrapSetupOverride } from "../shared/bootstrap-setup.js";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
 import { type WorktreeConfig } from "../utils/worktree.js";
 import type { AgentTimelineItem } from "./agent/agent-sdk-types.js";
@@ -12,9 +13,14 @@ export interface WorktreeBootstrapTerminalResult {
 export interface RunAsyncWorktreeBootstrapOptions {
     agentId: string;
     worktree: WorktreeConfig;
+    setupOverride?: BootstrapSetupOverride | null;
     terminalManager: TerminalManager | null;
     appendTimelineItem: (item: AgentTimelineItem) => Promise<boolean>;
     emitLiveTimelineItem?: (item: AgentTimelineItem) => Promise<boolean>;
+    onSetupSettled?: (result: {
+        setupStatus: "not_required" | "completed" | "failed";
+        errorMessage: string | null;
+    }) => Promise<void> | void;
     logger?: Logger;
 }
 export interface CreateAgentWorktreeOptions {

package/dist/server/server/worktree-bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree-bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/worktree-bootstrap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,CAAC;IACzB,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,kBAAkB,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAClE,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAiHD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,cAAc,CAAC,CASzB;AA+SD,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAgIf"}
+{"version":3,"file":"worktree-bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/worktree-bootstrap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAOL,KAAK,cAAc,EAKpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC9C,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,kBAAkB,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAClE,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE;QACxB,WAAW,EAAE,cAAc,GAAG,WAAW,GAAG,QAAQ,CAAC;QACrD,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;KAC7B,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAiJD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,cAAc,CAAC,CASzB;AA0qBD,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAqOf"}

package/dist/server/server/worktree-bootstrap.js

@@ -1,8 +1,37 @@
+import { readdirSync } from "node:fs";
+import { basename, join } from "node:path";
 import { v4 as uuidv4 } from "uuid";
-import { createWorktree, getWorktreeTerminalSpecs, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, WorktreeSetupError, } from "../utils/worktree.js";
+import { createWorktree, getWorktreeTerminalSpecs, resolveWorktreeBootstrapSetup, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, WorktreeSetupError, } from "../utils/worktree.js";
 const MAX_WORKTREE_SETUP_COMMAND_OUTPUT_BYTES = 64 * 1024;
 const WORKTREE_SETUP_TRUNCATION_MARKER = "\n...<output truncated in the middle>...\n";
 const WORKTREE_BOOTSTRAP_TERMINAL_READY_TIMEOUT_MS = 1500;
+const SETUP_TERMINAL_NAME = "Setup";
+const SETUP_SENTINEL_PREFIX = "__JUNCTION_SETUP_DONE__";
+const SETUP_COMMAND_START_SENTINEL_PREFIX = "__JUNCTION_SETUP_COMMAND_START__";
+const SETUP_COMMAND_DONE_SENTINEL_PREFIX = "__JUNCTION_SETUP_COMMAND_DONE__";
+const ANSI_ESCAPE_REGEX = /\u001B[\[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+function countCopiedFiles(rootPath) {
+    let total = 0;
+    const stack = [rootPath];
+    while (stack.length > 0) {
+        const currentPath = stack.pop();
+        if (!currentPath) {
+            continue;
+        }
+        for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+            if (entry.name === ".git") {
+                continue;
+            }
+            const nextPath = join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(nextPath);
+                continue;
+            }
+            total += 1;
+        }
+    }
+    return total;
+}
 function byteLength(text) {
     return Buffer.byteLength(text, "utf8");
 }
@@ -96,6 +125,44 @@ export async function createAgentWorktree(options) {
 function formatDurationMs(durationMs) {
     return `${(durationMs / 1000).toFixed(2)}s`;
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function quoteForShell(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function resolveSetupTerminalShells() {
+    const interactiveShell = process.env.SHELL || "/bin/sh";
+    const interactiveShellName = basename(interactiveShell).toLowerCase();
+    const supportsDashLc = interactiveShellName === "sh" || interactiveShellName === "bash" || interactiveShellName === "zsh";
+    return {
+        runnerShell: supportsDashLc ? interactiveShell : "/bin/sh",
+        interactiveShell,
+    };
+}
+function normalizeTerminalControlText(value) {
+    if (!value) {
+        return "";
+    }
+    const stripped = value.replace(ANSI_ESCAPE_REGEX, "");
+    let normalized = "";
+    for (const char of stripped) {
+        if (char === "\b") {
+            normalized = normalized.slice(0, -1);
+            continue;
+        }
+        if (char === "\r") {
+            normalized += "\n";
+            continue;
+        }
+        const codePoint = char.codePointAt(0) ?? 0;
+        if (codePoint < 0x20 && char !== "\n" && char !== "\t") {
+            continue;
+        }
+        normalized += char;
+    }
+    return normalized;
+}
 function commandStatusFromResult(result) {
     if (result.exitCode === null) {
         return "running";
@@ -184,6 +251,45 @@ function buildSetupTimelineItem(input) {
         error: { message: input.errorMessage ?? "Worktree setup failed" },
     };
 }
+function buildWorkspaceBootstrapTimelineItem(input) {
+    const detail = {
+        type: "workspace_bootstrap",
+        workspaceName: input.worktree.workspaceName,
+        baseBranch: input.worktree.baseBranch,
+        branchName: input.worktree.branchName,
+        worktreePath: input.worktree.worktreePath,
+        copiedFilesCount: input.copiedFilesCount,
+        setupStatus: input.setupStatus,
+    };
+    if (input.status === "running") {
+        return {
+            type: "tool_call",
+            name: "junction_workspace_bootstrap",
+            callId: input.callId,
+            status: "running",
+            detail,
+            error: null,
+        };
+    }
+    if (input.status === "completed") {
+        return {
+            type: "tool_call",
+            name: "junction_workspace_bootstrap",
+            callId: input.callId,
+            status: "completed",
+            detail,
+            error: null,
+        };
+    }
+    return {
+        type: "tool_call",
+        name: "junction_workspace_bootstrap",
+        callId: input.callId,
+        status: "failed",
+        detail,
+        error: { message: input.errorMessage ?? "Workspace bootstrap failed" },
+    };
+}
 function buildTerminalTimelineItem(input) {
     const detailInput = {
         worktreePath: input.worktree.worktreePath,
@@ -268,6 +374,225 @@ async function waitForTerminalBootstrapReadiness(terminal) {
         timeout = setTimeout(finish, WORKTREE_BOOTSTRAP_TERMINAL_READY_TIMEOUT_MS);
     });
 }
+function buildSetupTerminalBootstrapCommand(input) {
+    const lines = [
+        `__junction_setup_exec_shell=${quoteForShell(input.runnerShell)}`,
+        `__junction_setup_interactive_shell=${quoteForShell(input.interactiveShell)}`,
+        "__junction_setup_status=0",
+        "__junction_setup_run_command() {",
+        '  __junction_setup_index="$1"',
+        '  __junction_setup_command="$2"',
+        `  printf '\\n${SETUP_COMMAND_START_SENTINEL_PREFIX}:${input.token}:%s\\n' "$__junction_setup_index"`,
+        '  "$__junction_setup_exec_shell" -lc "$__junction_setup_command"',
+        "  __junction_setup_command_status=$?",
+        `  printf '\\n${SETUP_COMMAND_DONE_SENTINEL_PREFIX}:${input.token}:%s:%s\\n' "$__junction_setup_index" "$__junction_setup_command_status"`,
+        '  return "$__junction_setup_command_status"',
+        "}",
+    ];
+    for (const [index, command] of input.commands.entries()) {
+        lines.push('if [ "$__junction_setup_status" -eq 0 ]; then');
+        lines.push(`  __junction_setup_run_command ${index + 1} ${quoteForShell(command)} || __junction_setup_status=$?`);
+        lines.push("fi");
+    }
+    lines.push(`printf '\\n${SETUP_SENTINEL_PREFIX}:${input.token}:%s\\n' "$__junction_setup_status"`);
+    lines.push('exec "$__junction_setup_interactive_shell" -i || exec /bin/sh -i');
+    lines.push("");
+    return lines.join("\n");
+}
+function stripSetupProtocolOutput(output, token) {
+    if (!output) {
+        return "";
+    }
+    const protocolPattern = new RegExp([
+        escapeRegex(SETUP_COMMAND_START_SENTINEL_PREFIX),
+        escapeRegex(SETUP_COMMAND_DONE_SENTINEL_PREFIX),
+        escapeRegex(SETUP_SENTINEL_PREFIX),
+    ]
+        .map((prefix) => `\\r?\\n?${prefix}:${escapeRegex(token)}(?::\\d+){1,2}\\r?\\n?`)
+        .join("|"), "g");
+    return output.replace(protocolPattern, "\n");
+}
+async function runSetupCommandsInTerminal(options) {
+    const token = uuidv4();
+    const { runnerShell, interactiveShell } = resolveSetupTerminalShells();
+    // Ensure Terminal 1 is provisioned before Setup so both tabs always exist together.
+    await options.terminalManager.getTerminals(options.worktree.worktreePath);
+    const terminal = await options.terminalManager.createTerminal({
+        cwd: options.worktree.worktreePath,
+        name: SETUP_TERMINAL_NAME,
+        env: options.runtimeEnv,
+        shell: runnerShell,
+        shellArgs: [
+            "-lc",
+            buildSetupTerminalBootstrapCommand({
+                commands: options.setup.commands,
+                token,
+                runnerShell,
+                interactiveShell,
+            }),
+        ],
+    });
+    let terminalClosedError = null;
+    const commandOutputByIndex = new Map();
+    const commandStartedAtByIndex = new Map();
+    const resultsByIndex = new Map();
+    const startPattern = new RegExp(`^${escapeRegex(SETUP_COMMAND_START_SENTINEL_PREFIX)}:${escapeRegex(token)}:(\\d+)$`);
+    const donePattern = new RegExp(`^${escapeRegex(SETUP_COMMAND_DONE_SENTINEL_PREFIX)}:${escapeRegex(token)}:(\\d+):(\\d+)$`);
+    const setupDonePattern = new RegExp(`^${escapeRegex(SETUP_SENTINEL_PREFIX)}:${escapeRegex(token)}:(\\d+)$`);
+    let activeCommandIndex = null;
+    let normalizedBuffer = "";
+    const unsubscribeExit = terminal.onExit(() => {
+        terminalClosedError = "Setup terminal exited before the setup script completed.";
+    });
+    const buildOrderedResults = () => Array.from(resultsByIndex.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([, result]) => result);
+    try {
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let rawSubscription = null;
+            let exitPoll = null;
+            const cleanup = () => {
+                if (exitPoll) {
+                    clearInterval(exitPoll);
+                    exitPoll = null;
+                }
+                rawSubscription?.unsubscribe();
+                rawSubscription = null;
+            };
+            const settle = (callback) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                callback();
+            };
+            const handleError = (error) => {
+                settle(() => reject(error));
+            };
+            const processLine = (line) => {
+                const startMatch = startPattern.exec(line);
+                if (startMatch) {
+                    const commandIndex = Number.parseInt(startMatch[1] ?? "", 10);
+                    if (!Number.isFinite(commandIndex) || commandIndex < 1 || commandIndex > options.setup.commands.length) {
+                        return;
+                    }
+                    activeCommandIndex = commandIndex;
+                    commandStartedAtByIndex.set(commandIndex, Date.now());
+                    commandOutputByIndex.set(commandIndex, "");
+                    options.onEvent?.({
+                        type: "command_started",
+                        index: commandIndex,
+                        total: options.setup.commands.length,
+                        command: options.setup.commands[commandIndex - 1] ?? "",
+                        cwd: options.worktree.worktreePath,
+                    });
+                    return;
+                }
+                const doneMatch = donePattern.exec(line);
+                if (doneMatch) {
+                    const commandIndex = Number.parseInt(doneMatch[1] ?? "", 10);
+                    const exitCode = Number.parseInt(doneMatch[2] ?? "", 10);
+                    if (!Number.isFinite(commandIndex) || commandIndex < 1 || commandIndex > options.setup.commands.length) {
+                        return;
+                    }
+                    const stdout = stripSetupProtocolOutput(commandOutputByIndex.get(commandIndex) ?? "", token);
+                    const result = {
+                        command: options.setup.commands[commandIndex - 1] ?? "",
+                        cwd: options.worktree.worktreePath,
+                        stdout,
+                        stderr: "",
+                        exitCode: Number.isFinite(exitCode) ? exitCode : null,
+                        durationMs: Math.max(0, Date.now() - (commandStartedAtByIndex.get(commandIndex) ?? Date.now())),
+                    };
+                    resultsByIndex.set(commandIndex, result);
+                    if (activeCommandIndex === commandIndex) {
+                        activeCommandIndex = null;
+                    }
+                    options.onEvent?.({
+                        type: "command_completed",
+                        index: commandIndex,
+                        total: options.setup.commands.length,
+                        command: result.command,
+                        cwd: result.cwd,
+                        exitCode: result.exitCode,
+                        durationMs: result.durationMs,
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                    });
+                    if (result.exitCode !== 0) {
+                        handleError(new WorktreeSetupError(`Worktree setup command failed: ${result.command}`.trim(), buildOrderedResults()));
+                    }
+                    return;
+                }
+                const setupDoneMatch = setupDonePattern.exec(line);
+                if (setupDoneMatch) {
+                    const exitCode = Number.parseInt(setupDoneMatch[1] ?? "", 10);
+                    if (!Number.isFinite(exitCode) || exitCode !== 0) {
+                        handleError(new WorktreeSetupError("Worktree setup failed", buildOrderedResults()));
+                        return;
+                    }
+                    if (resultsByIndex.size !== options.setup.commands.length) {
+                        handleError(new Error("Setup terminal completed without recording all setup commands."));
+                        return;
+                    }
+                    settle(resolve);
+                    return;
+                }
+                if (activeCommandIndex === null) {
+                    return;
+                }
+                const outputChunk = `${line}\n`;
+                commandOutputByIndex.set(activeCommandIndex, `${commandOutputByIndex.get(activeCommandIndex) ?? ""}${outputChunk}`);
+                options.onEvent?.({
+                    type: "output",
+                    index: activeCommandIndex,
+                    total: options.setup.commands.length,
+                    command: options.setup.commands[activeCommandIndex - 1] ?? "",
+                    cwd: options.worktree.worktreePath,
+                    stream: "stdout",
+                    chunk: outputChunk,
+                });
+            };
+            rawSubscription = terminal.subscribeRaw((chunk) => {
+                if (settled) {
+                    return;
+                }
+                const normalizedChunk = normalizeTerminalControlText(chunk.data);
+                if (!normalizedChunk) {
+                    return;
+                }
+                normalizedBuffer = `${normalizedBuffer}${normalizedChunk}`;
+                let newlineIndex = normalizedBuffer.indexOf("\n");
+                while (newlineIndex !== -1) {
+                    const line = normalizedBuffer.slice(0, newlineIndex);
+                    normalizedBuffer = normalizedBuffer.slice(newlineIndex + 1);
+                    processLine(line);
+                    newlineIndex = normalizedBuffer.indexOf("\n");
+                }
+            }, { fromOffset: 0 });
+            if (terminalClosedError) {
+                handleError(new Error(terminalClosedError));
+                return;
+            }
+            exitPoll = setInterval(() => {
+                if (settled) {
+                    return;
+                }
+                if (terminalClosedError) {
+                    handleError(new Error(terminalClosedError));
+                }
+            }, 25);
+        });
+    }
+    finally {
+        unsubscribeExit();
+    }
+    return Array.from(resultsByIndex.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([, result]) => result);
+}
 async function runWorktreeTerminalBootstrap(options, runtimeEnv) {
     const terminalSpecs = getWorktreeTerminalSpecs(options.worktree.worktreePath);
     if (terminalSpecs.length === 0) {
@@ -336,13 +661,44 @@ async function runWorktreeTerminalBootstrap(options, runtimeEnv) {
     }));
 }
 export async function runAsyncWorktreeBootstrap(options) {
+    const bootstrapCallId = uuidv4();
     const setupCallId = uuidv4();
     let setupResults = [];
     let runtimeEnv = null;
+    const copiedFilesCount = countCopiedFiles(options.worktree.worktreePath);
+    const resolvedSetup = resolveWorktreeBootstrapSetup({
+        repoRoot: options.worktree.worktreePath,
+        override: options.setupOverride,
+    });
+    const hasSetupCommands = Boolean(resolvedSetup && resolvedSetup.commands.length > 0);
     const emitLiveTimelineItem = options.emitLiveTimelineItem;
     const runningResultsByIndex = new Map();
     const outputAccumulatorsByIndex = new Map();
     let liveEmitQueue = Promise.resolve();
+    const started = await options.appendTimelineItem(buildWorkspaceBootstrapTimelineItem({
+        callId: bootstrapCallId,
+        status: "running",
+        worktree: options.worktree,
+        copiedFilesCount,
+        setupStatus: hasSetupCommands ? "running" : "not_required",
+        errorMessage: null,
+    }));
+    if (!started) {
+        return;
+    }
+    if (hasSetupCommands) {
+        const setupStarted = await options.appendTimelineItem(buildSetupTimelineItem({
+            callId: setupCallId,
+            status: "running",
+            worktree: options.worktree,
+            results: [],
+            outputAccumulatorsByIndex,
+            errorMessage: null,
+        }));
+        if (!setupStarted) {
+            return;
+        }
+    }
     const queueLiveRunningEmit = () => {
         if (!emitLiveTimelineItem) {
             return;
@@ -375,12 +731,8 @@ export async function runAsyncWorktreeBootstrap(options) {
             cwd: options.worktree.worktreePath,
             env: runtimeEnv,
         });
-        setupResults = await runWorktreeSetupCommands({
-            worktreePath: options.worktree.worktreePath,
-            branchName: options.worktree.branchName,
-            cleanupOnFailure: false,
-            runtimeEnv,
-            onEvent: (event) => {
+        if (resolvedSetup) {
+            const handleSetupEvent = (event) => {
                 const existing = runningResultsByIndex.get(event.index);
                 const baseResult = existing ?? {
                     command: event.command,
@@ -390,48 +742,80 @@ export async function runAsyncWorktreeBootstrap(options) {
                     exitCode: null,
                     durationMs: 0,
                 };
-                if (event.type === "output") {
+                if (event.type === "output" && event.chunk) {
                     const outputAccumulator = outputAccumulatorsByIndex.get(event.index) ??
                         createMiddleTruncationAccumulator();
                     appendToMiddleTruncationAccumulator(outputAccumulator, event.chunk);
                     outputAccumulatorsByIndex.set(event.index, outputAccumulator);
-                    runningResultsByIndex.set(event.index, {
-                        ...baseResult,
-                        // Keep the timeline command model lightweight; output is carried in
-                        // outputAccumulatorsByIndex.
-                        stdout: baseResult.stdout,
-                        stderr: baseResult.stderr,
-                    });
+                    runningResultsByIndex.set(event.index, baseResult);
                     queueLiveRunningEmit();
                     return;
                 }
                 if (event.type === "command_completed") {
+                    const outputAccumulator = outputAccumulatorsByIndex.get(event.index) ??
+                        createMiddleTruncationAccumulator();
+                    appendToMiddleTruncationAccumulator(outputAccumulator, `${event.stdout ?? ""}${event.stderr ?? ""}`);
+                    outputAccumulatorsByIndex.set(event.index, outputAccumulator);
                     runningResultsByIndex.set(event.index, {
                         ...baseResult,
-                        stdout: event.stdout,
-                        stderr: event.stderr,
-                        exitCode: event.exitCode,
-                        durationMs: event.durationMs,
+                        stdout: event.stdout ?? "",
+                        stderr: event.stderr ?? "",
+                        exitCode: event.exitCode ?? null,
+                        durationMs: event.durationMs ?? 0,
                     });
                     queueLiveRunningEmit();
                     return;
                 }
                 runningResultsByIndex.set(event.index, baseResult);
                 queueLiveRunningEmit();
-            },
-        });
+            };
+            setupResults =
+                options.terminalManager
+                    ? await runSetupCommandsInTerminal({
+                        terminalManager: options.terminalManager,
+                        worktree: options.worktree,
+                        runtimeEnv,
+                        setup: resolvedSetup,
+                        onEvent: handleSetupEvent,
+                    })
+                    : await runWorktreeSetupCommands({
+                        worktreePath: options.worktree.worktreePath,
+                        branchName: options.worktree.branchName,
+                        cleanupOnFailure: false,
+                        commands: resolvedSetup.commands,
+                        runtimeEnv,
+                        onEvent: handleSetupEvent,
+                    });
+        }
         await liveEmitQueue;
-        const completed = await options.appendTimelineItem(buildSetupTimelineItem({
-            callId: setupCallId,
+        if (hasSetupCommands) {
+            const completed = await options.appendTimelineItem(buildSetupTimelineItem({
+                callId: setupCallId,
+                status: "completed",
+                worktree: options.worktree,
+                results: setupResults,
+                outputAccumulatorsByIndex,
+                errorMessage: null,
+            }));
+            if (!completed) {
+                return;
+            }
+        }
+        const bootstrapCompleted = await options.appendTimelineItem(buildWorkspaceBootstrapTimelineItem({
+            callId: bootstrapCallId,
             status: "completed",
             worktree: options.worktree,
-            results: setupResults,
-            outputAccumulatorsByIndex,
+            copiedFilesCount,
+            setupStatus: hasSetupCommands ? "completed" : "not_required",
             errorMessage: null,
         }));
-        if (!completed) {
+        if (!bootstrapCompleted) {
             return;
         }
+        await options.onSetupSettled?.({
+            setupStatus: hasSetupCommands ? "completed" : "not_required",
+            errorMessage: null,
+        });
     }
     catch (error) {
         if (error instanceof WorktreeSetupError) {
@@ -439,14 +823,28 @@ export async function runAsyncWorktreeBootstrap(options) {
         }
         await liveEmitQueue;
         const message = error instanceof Error ? error.message : String(error);
-        await options.appendTimelineItem(buildSetupTimelineItem({
-            callId: setupCallId,
+        if (hasSetupCommands) {
+            await options.appendTimelineItem(buildSetupTimelineItem({
+                callId: setupCallId,
+                status: "failed",
+                worktree: options.worktree,
+                results: setupResults,
+                outputAccumulatorsByIndex,
+                errorMessage: message,
+            }));
+        }
+        await options.appendTimelineItem(buildWorkspaceBootstrapTimelineItem({
+            callId: bootstrapCallId,
             status: "failed",
             worktree: options.worktree,
-            results: setupResults,
-            outputAccumulatorsByIndex,
+            copiedFilesCount,
+            setupStatus: "failed",
             errorMessage: message,
         }));
+        await options.onSetupSettled?.({
+            setupStatus: "failed",
+            errorMessage: message,
+        });
         return;
     }
     await runWorktreeTerminalBootstrap(options, runtimeEnv);