@cluesmith/codev 2.0.0-rc.7 → 2.0.0-rc.70

package/dist/agent-farm/commands/spawn.js

@@ -7,33 +7,142 @@
  * - protocol: --protocol    Spawn to run a protocol (cleanup, experiment, etc.)
  * - shell:    --shell       Bare Claude session (no prompt, no worktree)
  */
-import { resolve, basename, join } from 'node:path';
-import { existsSync, readFileSync, writeFileSync, chmodSync, readdirSync, symlinkSync, unlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { randomUUID } from 'node:crypto';
+import { resolve, basename } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, chmodSync, readdirSync, symlinkSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { getConfig, ensureDirectories, getResolvedCommands } from '../utils/index.js';
 import { logger, fatal } from '../utils/logger.js';
-import { run, commandExists, findAvailablePort, spawnTtyd } from '../utils/shell.js';
-import { loadState, upsertBuilder } from '../state.js';
+import { run, commandExists } from '../utils/shell.js';
+import { upsertBuilder } from '../state.js';
 import { loadRolePrompt } from '../utils/roles.js';
+// Tower port — the single HTTP server since Spec 0090
+const DEFAULT_TOWER_PORT = 4100;
 /**
- * Generate a short 4-character base64-encoded ID
- * Uses URL-safe base64 (a-z, A-Z, 0-9, -, _) for filesystem-safe IDs
+ * Simple Handlebars-like template renderer
+ * Supports: {{variable}}, {{#if condition}}...{{/if}}, {{object.property}}
+ */
+function renderTemplate(template, context) {
+    let result = template;
+    // Process {{#if condition}}...{{/if}} blocks
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const ifMatch = result.match(/\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/);
+        if (!ifMatch)
+            break;
+        const [fullMatch, condition, content] = ifMatch;
+        const value = getNestedValue(context, condition);
+        result = result.replace(fullMatch, value ? content : '');
+    }
+    // Process {{variable}} and {{object.property}} substitutions
+    result = result.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_, path) => {
+        const value = getNestedValue(context, path);
+        if (value === undefined || value === null)
+            return '';
+        return String(value);
+    });
+    // Clean up any double newlines left from removed sections
+    result = result.replace(/\n{3,}/g, '\n\n');
+    return result.trim();
+}
+/**
+ * Get nested value from object using dot notation
  */
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
 /**
- * Get the project name from config (basename of projectRoot)
- * Used to namespace tmux sessions and prevent cross-project collisions
+ * Load builder-prompt.md template for a protocol
  */
-function getProjectName(config) {
-    return basename(config.projectRoot);
+function loadBuilderPromptTemplate(config, protocolName) {
+    const templatePath = resolve(config.codevDir, 'protocols', protocolName, 'builder-prompt.md');
+    if (existsSync(templatePath)) {
+        return readFileSync(templatePath, 'utf-8');
+    }
+    return null;
+}
+/**
+ * Build the prompt using protocol template or fallback to inline prompt
+ */
+function buildPromptFromTemplate(config, protocolName, context) {
+    const template = loadBuilderPromptTemplate(config, protocolName);
+    if (template) {
+        logger.info(`Using template: protocols/${protocolName}/builder-prompt.md`);
+        return renderTemplate(template, context);
+    }
+    // Fallback: no template found, return a basic prompt
+    logger.debug(`No template found for ${protocolName}, using inline prompt`);
+    return buildFallbackPrompt(protocolName, context);
+}
+/**
+ * Build a fallback prompt when no template exists
+ */
+function buildFallbackPrompt(protocolName, context) {
+    const modeInstructions = context.mode === 'strict'
+        ? `## Mode: STRICT
+Porch orchestrates your work. Run: \`porch next\` to get your next tasks.`
+        : `## Mode: SOFT
+You follow the protocol yourself. The architect monitors your work and verifies compliance.`;
+    let prompt = `# ${protocolName.toUpperCase()} Builder (${context.mode} mode)
+
+You are implementing ${context.input_description}.
+
+${modeInstructions}
+
+## Protocol
+Follow the ${protocolName.toUpperCase()} protocol: \`codev/protocols/${protocolName}/protocol.md\`
+Read and internalize the protocol before starting any work.
+`;
+    if (context.spec) {
+        prompt += `\n## Spec\nRead the specification at: \`${context.spec.path}\`\n`;
+    }
+    if (context.plan) {
+        prompt += `\n## Plan\nFollow the implementation plan at: \`${context.plan.path}\`\n`;
+    }
+    if (context.issue) {
+        prompt += `\n## Issue #${context.issue.number}
+**Title**: ${context.issue.title}
+
+**Description**:
+${context.issue.body || '(No description provided)'}
+`;
+    }
+    if (context.task_text) {
+        prompt += `\n## Task\n${context.task_text}\n`;
+    }
+    return prompt;
 }
+// =============================================================================
+// Resume Context
+// =============================================================================
 /**
- * Get a namespaced tmux session name: builder-{project}-{id}
+ * Build a resume notice to prepend to the builder prompt.
+ * Tells the builder this is a resumed session and to check existing porch state.
  */
-function getSessionName(config, builderId) {
-    return `builder-${getProjectName(config)}-${builderId}`;
+function buildResumeNotice(_projectId) {
+    return `## RESUME SESSION
+
+This is a **resumed** builder session. A previous session was working in this worktree.
+
+Start by running \`porch next\` to check your current state and get next tasks.
+If porch state exists, continue from where the previous session left off.
+If porch reports "not found", run \`porch init\` to re-initialize.
+`;
 }
+// =============================================================================
+// ID and Session Management
+// =============================================================================
+/**
+ * Generate a short 4-character base64-encoded ID
+ * Uses URL-safe base64 (a-z, A-Z, 0-9, -, _) for filesystem-safe IDs
+ */
 function generateShortId() {
     // Generate random 24-bit number and base64 encode to 4 chars
     const num = Math.floor(Math.random() * 0xFFFFFF);
@@ -45,64 +154,27 @@ function generateShortId() {
         .substring(0, 4);
 }
 /**
- * Format current date/time as YYYY-MM-DD HH:MM
- */
-function formatDateTime() {
-    const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, '0');
-    const day = String(now.getDate()).padStart(2, '0');
-    const hours = String(now.getHours()).padStart(2, '0');
-    const minutes = String(now.getMinutes()).padStart(2, '0');
-    return `${year}-${month}-${day} ${hours}:${minutes}`;
-}
-/**
- * Rename a Claude session after it starts
- * Uses tmux buffer approach for reliable text input (same as af send)
- */
-function renameClaudeSession(sessionName, displayName) {
-    // Wait for Claude to be ready, then send /rename command
-    setTimeout(async () => {
-        try {
-            // Add date/time to the display name
-            const nameWithTime = `${displayName} (${formatDateTime()})`;
-            const renameCommand = `/rename ${nameWithTime}`;
-            // Use buffer approach for reliable input (like af send)
-            const tempFile = join(tmpdir(), `rename-${randomUUID()}.txt`);
-            const bufferName = `rename-${sessionName}`;
-            writeFileSync(tempFile, renameCommand);
-            await run(`tmux load-buffer -b "${bufferName}" "${tempFile}"`);
-            await run(`tmux paste-buffer -b "${bufferName}" -t "${sessionName}"`);
-            await run(`tmux delete-buffer -b "${bufferName}"`).catch(() => { });
-            await run(`tmux send-keys -t "${sessionName}" Enter`);
-            // Clean up temp file
-            try {
-                unlinkSync(tempFile);
-            }
-            catch { }
-        }
-        catch {
-            // Non-fatal - session naming is a nice-to-have
-        }
-    }, 5000); // 5 second delay for Claude to initialize
-}
-/**
- * Validate spawn options - ensure exactly one mode is selected
+ * Validate spawn options - ensure exactly one input mode is selected
+ * Note: --protocol serves dual purpose:
+ *   1. As an input mode when used alone (e.g., `af spawn --protocol experiment`)
+ *   2. As a protocol override when combined with other input modes (e.g., `af spawn -p 0001 --protocol tick`)
  */
 function validateSpawnOptions(options) {
-    const modes = [
+    // Count input modes (excluding --protocol which can be used as override)
+    const inputModes = [
         options.project,
         options.task,
-        options.protocol,
         options.shell,
         options.worktree,
         options.issue,
     ].filter(Boolean);
-    if (modes.length === 0) {
+    // --protocol alone is a valid input mode
+    const protocolAlone = options.protocol && inputModes.length === 0;
+    if (inputModes.length === 0 && !protocolAlone) {
         fatal('Must specify one of: --project (-p), --issue (-i), --task, --protocol, --shell, --worktree\n\nRun "af spawn --help" for examples.');
     }
-    if (modes.length > 1) {
-        fatal('Flags --project, --issue, --task, --protocol, --shell, --worktree are mutually exclusive');
+    if (inputModes.length > 1) {
+        fatal('Flags --project, --issue, --task, --shell, --worktree are mutually exclusive');
     }
     if (options.files && !options.task) {
         fatal('--files requires --task');
@@ -110,23 +182,35 @@ function validateSpawnOptions(options) {
     if ((options.noComment || options.force) && !options.issue) {
         fatal('--no-comment and --force require --issue');
     }
+    // --protocol as override cannot be used with --shell or --worktree
+    if (options.protocol && inputModes.length > 0 && (options.shell || options.worktree)) {
+        fatal('--protocol cannot be used with --shell or --worktree (no protocol applies)');
+    }
+    // --use-protocol is now deprecated in favor of --protocol as universal override
+    // Keep for backwards compatibility but prefer --protocol
+    if (options.useProtocol && (options.shell || options.worktree)) {
+        fatal('--use-protocol cannot be used with --shell or --worktree (no protocol applies)');
+    }
 }
 /**
  * Determine the spawn mode from options
+ * Note: --protocol can be used as both an input mode (alone) or an override (with other modes)
  */
 function getSpawnMode(options) {
+    // Primary input modes take precedence over --protocol as override
     if (options.project)
         return 'spec';
     if (options.issue)
         return 'bugfix';
     if (options.task)
         return 'task';
-    if (options.protocol)
-        return 'protocol';
     if (options.shell)
         return 'shell';
     if (options.worktree)
         return 'worktree';
+    // --protocol alone is the protocol input mode
+    if (options.protocol)
+        return 'protocol';
     throw new Error('No mode specified');
 }
 // loadRolePrompt imported from ../utils/roles.js
@@ -189,31 +273,142 @@ function validateProtocol(config, protocolName) {
     }
 }
 /**
- * Check for required dependencies
+ * Load and parse a protocol.json file
  */
-async function checkDependencies() {
-    if (!(await commandExists('git'))) {
-        fatal('git not found');
+function loadProtocol(config, protocolName) {
+    const protocolJsonPath = resolve(config.codevDir, 'protocols', protocolName, 'protocol.json');
+    if (!existsSync(protocolJsonPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(protocolJsonPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        logger.warn(`Warning: Failed to parse ${protocolJsonPath}`);
+        return null;
+    }
+}
+/**
+ * Resolve which protocol to use based on precedence:
+ * 1. Explicit --protocol flag when used as override (with other input modes)
+ * 2. Explicit --use-protocol flag (backwards compatibility)
+ * 3. Spec file **Protocol**: header (for --project mode)
+ * 4. Hardcoded defaults (spir for specs, bugfix for issues)
+ */
+async function resolveProtocol(options, config) {
+    // Count input modes to determine if --protocol is being used as override
+    const inputModes = [
+        options.project,
+        options.task,
+        options.shell,
+        options.worktree,
+        options.issue,
+    ].filter(Boolean);
+    const protocolAsOverride = options.protocol && inputModes.length > 0;
+    // 1. --protocol as override always wins when combined with other input modes
+    if (protocolAsOverride) {
+        validateProtocol(config, options.protocol);
+        return options.protocol.toLowerCase();
+    }
+    // 2. Explicit --use-protocol override (backwards compatibility)
+    if (options.useProtocol) {
+        validateProtocol(config, options.useProtocol);
+        return options.useProtocol.toLowerCase();
+    }
+    // 3. For spec mode, check spec file header (preserves existing behavior)
+    if (options.project) {
+        const specFile = await findSpecFile(config.codevDir, options.project);
+        if (specFile) {
+            const specContent = readFileSync(specFile, 'utf-8');
+            const match = specContent.match(/\*\*Protocol\*\*:\s*(\w+)/i);
+            if (match) {
+                const protocolFromSpec = match[1].toLowerCase();
+                // Validate the protocol exists
+                try {
+                    validateProtocol(config, protocolFromSpec);
+                    return protocolFromSpec;
+                }
+                catch {
+                    // If protocol from spec doesn't exist, fall through to defaults
+                    logger.warn(`Warning: Protocol "${match[1]}" from spec not found, using default`);
+                }
+            }
+        }
+    }
+    // 4. Hardcoded defaults based on input type
+    if (options.project)
+        return 'spir';
+    if (options.issue)
+        return 'bugfix';
+    // --protocol alone (not as override) uses the protocol name itself
+    if (options.protocol)
+        return options.protocol.toLowerCase();
+    if (options.task)
+        return 'spir';
+    return 'spir'; // Final fallback
+}
+// Note: GitHubIssue interface is defined later in the file
+/**
+ * Resolve the builder mode (strict vs soft)
+ * Precedence:
+ * 1. Explicit --strict or --soft flags (always win)
+ * 2. Protocol defaults from protocol.json
+ * 3. Input type defaults (spec = strict, all others = soft)
+ */
+function resolveMode(options, protocol) {
+    // 1. Explicit flags always win
+    if (options.strict && options.soft) {
+        fatal('--strict and --soft are mutually exclusive');
+    }
+    if (options.strict) {
+        return 'strict';
+    }
+    if (options.soft) {
+        return 'soft';
     }
-    if (!(await commandExists('ttyd'))) {
-        fatal('ttyd not found. Install with: brew install ttyd');
+    // 2. Protocol defaults from protocol.json
+    if (protocol?.defaults?.mode) {
+        return protocol.defaults.mode;
     }
+    // 3. Input type defaults: only spec mode defaults to strict
+    if (options.project) {
+        return 'strict';
+    }
+    // All other modes default to soft
+    return 'soft';
 }
 /**
- * Find an available port, avoiding ports already in use by other builders
+ * Execute pre-spawn hooks defined in protocol.json
+ * Hooks are data-driven but reuse existing implementation logic
  */
-async function findFreePort(config) {
-    const state = loadState();
-    const usedPorts = new Set();
-    for (const b of state.builders || []) {
-        if (b.port)
-            usedPorts.add(b.port);
+async function executePreSpawnHooks(protocol, context) {
+    if (!protocol?.hooks?.['pre-spawn'])
+        return;
+    const hooks = protocol.hooks['pre-spawn'];
+    // collision-check: reuses existing checkBugfixCollisions() logic
+    if (hooks['collision-check'] && context.issueNumber && context.issue && context.worktreePath) {
+        await checkBugfixCollisions(context.issueNumber, context.worktreePath, context.issue, !!context.force);
     }
-    let port = config.builderPortRange[0];
-    while (usedPorts.has(port)) {
-        port++;
+    // comment-on-issue: posts comment to GitHub issue
+    if (hooks['comment-on-issue'] && context.issueNumber && !context.noComment) {
+        const message = hooks['comment-on-issue'];
+        logger.info('Commenting on issue...');
+        try {
+            await run(`gh issue comment ${context.issueNumber} --body "${message}"`);
+        }
+        catch {
+            logger.warn('Warning: Failed to comment on issue (continuing anyway)');
+        }
+    }
+}
+/**
+ * Check for required dependencies
+ */
+async function checkDependencies() {
+    if (!(await commandExists('git'))) {
+        fatal('git not found');
     }
-    return findAvailablePort(port);
 }
 /**
  * Create git branch and worktree
@@ -248,12 +443,33 @@ async function createWorktree(config, branchName, worktreePath) {
     }
 }
 /**
- * Start tmux session and ttyd for a builder
+ * Create a terminal session via the Tower REST API.
+ * The Tower server must be running (port 4100).
+ */
+async function createPtySession(config, command, args, cwd, registration) {
+    const body = { command, args, cwd, cols: 200, rows: 50, persistent: true };
+    if (registration) {
+        body.projectPath = registration.projectPath;
+        body.type = registration.type;
+        body.roleId = registration.roleId;
+    }
+    const response = await fetch(`http://localhost:${DEFAULT_TOWER_PORT}/api/terminals`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to create PTY session: ${response.status} ${text}`);
+    }
+    const result = await response.json();
+    return { terminalId: result.id };
+}
+/**
+ * Start a terminal session for a builder
  */
 async function startBuilderSession(config, builderId, worktreePath, baseCmd, prompt, roleContent, roleSource) {
-    const port = await findFreePort(config);
-    const sessionName = getSessionName(config, builderId);
-    logger.info('Creating tmux session...');
+    logger.info('Creating terminal session...');
     // Write initial prompt to a file for reference
     const promptFile = resolve(worktreePath, '.builder-prompt.txt');
     writeFileSync(promptFile, prompt);
@@ -264,83 +480,66 @@ async function startBuilderSession(config, builderId, worktreePath, baseCmd, pro
         // Write role to a file and use $(cat) to avoid shell escaping issues
         const roleFile = resolve(worktreePath, '.builder-role.md');
         // Inject the actual dashboard port into the role prompt
-        const roleWithPort = roleContent.replace(/\{PORT\}/g, String(config.dashboardPort));
+        const roleWithPort = roleContent.replace(/\{PORT\}/g, String(DEFAULT_TOWER_PORT));
         writeFileSync(roleFile, roleWithPort);
         logger.info(`Loaded role (${roleSource})`);
         scriptContent = `#!/bin/bash
-exec ${baseCmd} --append-system-prompt "$(cat '${roleFile}')" "$(cat '${promptFile}')"
+cd "${worktreePath}"
+while true; do
+  ${baseCmd} --append-system-prompt "$(cat '${roleFile}')" "$(cat '${promptFile}')"
+  echo ""
+  echo "Claude exited. Restarting in 2 seconds... (Ctrl+C to quit)"
+  sleep 2
+done
 `;
     }
     else {
         scriptContent = `#!/bin/bash
-exec ${baseCmd} "$(cat '${promptFile}')"
+cd "${worktreePath}"
+while true; do
+  ${baseCmd} "$(cat '${promptFile}')"
+  echo ""
+  echo "Claude exited. Restarting in 2 seconds... (Ctrl+C to quit)"
+  sleep 2
+done
 `;
     }
     writeFileSync(scriptPath, scriptContent);
     chmodSync(scriptPath, '755');
-    // Create tmux session running the script
-    await run(`tmux new-session -d -s "${sessionName}" -x 200 -y 50 -c "${worktreePath}" "${scriptPath}"`);
-    await run(`tmux set-option -t "${sessionName}" status off`);
-    // Enable mouse scrolling in tmux
-    await run('tmux set -g mouse on');
-    await run('tmux set -g set-clipboard on');
-    await run('tmux set -g allow-passthrough on');
-    // Copy selection to clipboard when mouse is released (pbcopy for macOS)
-    await run('tmux bind-key -T copy-mode MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    await run('tmux bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    // Start ttyd connecting to the tmux session
-    logger.info('Starting builder terminal...');
-    const customIndexPath = resolve(config.templatesDir, 'ttyd-index.html');
-    const hasCustomIndex = existsSync(customIndexPath);
-    if (hasCustomIndex) {
-        logger.info('Using custom terminal with file click support');
-    }
-    const ttydProcess = spawnTtyd({
-        port,
-        sessionName,
-        cwd: worktreePath,
-        customIndexPath: hasCustomIndex ? customIndexPath : undefined,
-    });
-    if (!ttydProcess?.pid) {
-        fatal('Failed to start ttyd process for builder');
-    }
-    // Rename Claude session for better history tracking
-    renameClaudeSession(sessionName, `Builder ${builderId}`);
-    return { port, pid: ttydProcess.pid, sessionName };
+    // Create PTY session via Tower REST API (shepherd for persistence)
+    logger.info('Creating PTY terminal session...');
+    const { terminalId } = await createPtySession(config, '/bin/bash', [scriptPath], worktreePath, { projectPath: config.projectRoot, type: 'builder', roleId: builderId });
+    logger.info(`Terminal session created: ${terminalId}`);
+    return { terminalId };
 }
 /**
- * Start a shell session (no worktree, just tmux + ttyd)
+ * Start a shell session (no worktree, just node-pty)
  */
 async function startShellSession(config, shellId, baseCmd) {
-    const port = await findFreePort(config);
-    const sessionName = `shell-${shellId}`;
-    logger.info('Creating tmux session...');
-    // Shell mode: just launch Claude with no prompt
-    await run(`tmux new-session -d -s "${sessionName}" -x 200 -y 50 -c "${config.projectRoot}" "${baseCmd}"`);
-    await run(`tmux set-option -t "${sessionName}" status off`);
-    // Enable mouse scrolling in tmux
-    await run('tmux set -g mouse on');
-    await run('tmux set -g set-clipboard on');
-    await run('tmux set -g allow-passthrough on');
-    // Copy selection to clipboard when mouse is released (pbcopy for macOS)
-    await run('tmux bind-key -T copy-mode MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    await run('tmux bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    // Start ttyd connecting to the tmux session
-    logger.info('Starting shell terminal...');
-    const customIndexPath = resolve(config.templatesDir, 'ttyd-index.html');
-    const hasCustomIndex = existsSync(customIndexPath);
-    const ttydProcess = spawnTtyd({
-        port,
-        sessionName,
-        cwd: config.projectRoot,
-        customIndexPath: hasCustomIndex ? customIndexPath : undefined,
-    });
-    if (!ttydProcess?.pid) {
-        fatal('Failed to start ttyd process for shell');
+    // Create PTY session via REST API
+    logger.info('Creating PTY terminal session for shell...');
+    const { terminalId } = await createPtySession(config, '/bin/bash', ['-c', baseCmd], config.projectRoot, { projectPath: config.projectRoot, type: 'shell', roleId: shellId });
+    logger.info(`Shell terminal session created: ${terminalId}`);
+    return { terminalId };
+}
+/**
+ * Pre-initialize porch in a worktree so the builder doesn't need to self-correct.
+ * Non-fatal: logs a warning on failure since the builder can still init manually.
+ */
+async function initPorchInWorktree(worktreePath, protocol, projectId, projectName) {
+    logger.info('Initializing porch...');
+    try {
+        // Sanitize inputs to prevent shell injection (defense-in-depth;
+        // callers already use slugified names, but be safe)
+        const safeName = projectName.replace(/[^a-z0-9_-]/gi, '-');
+        const safeProto = protocol.replace(/[^a-z0-9_-]/gi, '');
+        const safeId = projectId.replace(/[^a-z0-9_-]/gi, '');
+        await run(`porch init ${safeProto} ${safeId} "${safeName}"`, { cwd: worktreePath });
+        logger.info(`Porch initialized: ${projectId}`);
+    }
+    catch (error) {
+        logger.warn(`Warning: Failed to initialize porch (builder can init manually): ${error}`);
     }
-    // Rename Claude session for better history tracking
-    renameClaudeSession(sessionName, `Shell ${shellId}`);
-    return { port, pid: ttydProcess.pid, sessionName };
 }
 // =============================================================================
 // Mode-specific spawn implementations
@@ -362,56 +561,77 @@ async function spawnSpec(options, config) {
     // Check for corresponding plan file
     const planFile = resolve(config.codevDir, 'plans', `${specName}.md`);
     const hasPlan = existsSync(planFile);
-    logger.header(`Spawning Builder ${builderId} (spec)`);
+    logger.header(`${options.resume ? 'Resuming' : 'Spawning'} Builder ${builderId} (spec)`);
     logger.kv('Spec', specFile);
     logger.kv('Branch', branchName);
     logger.kv('Worktree', worktreePath);
     await ensureDirectories(config);
     await checkDependencies();
-    await createWorktree(config, branchName, worktreePath);
-    // Parse protocol from spec file metadata
-    const specContent = readFileSync(specFile, 'utf-8');
-    const protocolMatch = specContent.match(/\*\*Protocol\*\*:\s*(\w+)/i);
-    const protocol = protocolMatch ? protocolMatch[1].toUpperCase() : 'SPIDER';
-    const protocolPath = `codev/protocols/${protocol.toLowerCase()}/protocol.md`;
-    // Build the prompt
+    if (options.resume) {
+        if (!existsSync(worktreePath)) {
+            fatal(`Cannot resume: worktree does not exist at ${worktreePath}`);
+        }
+        if (!existsSync(resolve(worktreePath, '.git'))) {
+            fatal(`Cannot resume: ${worktreePath} is not a valid git worktree`);
+        }
+        logger.info('Resuming existing worktree (skipping creation)');
+    }
+    else {
+        await createWorktree(config, branchName, worktreePath);
+    }
+    // Resolve protocol using precedence: --use-protocol > spec header > default
+    const protocol = await resolveProtocol(options, config);
+    const protocolPath = `codev/protocols/${protocol}/protocol.md`;
+    // Load protocol definition for potential hooks/config
+    const protocolDef = loadProtocol(config, protocol);
+    // Resolve mode: --soft flag > protocol defaults > input type defaults
+    const mode = resolveMode(options, protocolDef);
+    logger.kv('Protocol', protocol.toUpperCase());
+    logger.kv('Mode', mode.toUpperCase());
+    // Pre-initialize porch so the builder doesn't need to figure out project ID
+    if (!options.resume) {
+        const porchProjectName = specName.replace(new RegExp(`^${projectId}-`), '');
+        await initPorchInWorktree(worktreePath, protocol, projectId, porchProjectName);
+    }
+    // Build the prompt using template
     const specRelPath = `codev/specs/${specName}.md`;
     const planRelPath = `codev/plans/${specName}.md`;
-    let initialPrompt = `## Protocol
-Follow the ${protocol} protocol STRICTLY: ${protocolPath}
-Read and internalize the protocol before starting any work.
-
-## Task
-Implement the feature specified in ${specRelPath}.`;
+    const templateContext = {
+        protocol_name: protocol.toUpperCase(),
+        mode,
+        mode_soft: mode === 'soft',
+        mode_strict: mode === 'strict',
+        project_id: projectId,
+        input_description: `the feature specified in ${specRelPath}`,
+        spec: { path: specRelPath, name: specName },
+    };
     if (hasPlan) {
-        initialPrompt += ` Follow the implementation plan in ${planRelPath}.`;
+        templateContext.plan = { path: planRelPath, name: specName };
     }
-    initialPrompt += `
-
-Start by reading the protocol, spec${hasPlan ? ', and plan' : ''}, then begin implementation.`;
+    const initialPrompt = buildPromptFromTemplate(config, protocol, templateContext);
+    const resumeNotice = options.resume ? `\n${buildResumeNotice(projectId)}\n` : '';
     const builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition.
-
+${resumeNotice}
 ${initialPrompt}`;
     // Load role
     const role = options.noRole ? null : loadRolePrompt(config, 'builder');
     const commands = getResolvedCommands();
-    const { port, pid, sessionName } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
+    const { terminalId } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
     const builder = {
         id: builderId,
         name: specName,
-        port,
-        pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'init',
         worktree: worktreePath,
         branch: branchName,
-        tmuxSession: sessionName,
         type: 'spec',
+        terminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Builder ${builderId} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Mode', mode === 'strict' ? 'Strict (porch-driven)' : 'Soft (protocol-guided)');
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${terminalId}`);
 }
 /**
  * Spawn builder for an ad-hoc task
@@ -422,7 +642,7 @@ async function spawnTask(options, config) {
     const builderId = `task-${shortId}`;
     const branchName = `builder/task-${shortId}`;
     const worktreePath = resolve(config.buildersDir, builderId);
-    logger.header(`Spawning Builder ${builderId} (task)`);
+    logger.header(`${options.resume ? 'Resuming' : 'Spawning'} Builder ${builderId} (task)`);
     logger.kv('Task', taskText.substring(0, 60) + (taskText.length > 60 ? '...' : ''));
     logger.kv('Branch', branchName);
     logger.kv('Worktree', worktreePath);
@@ -431,34 +651,68 @@ async function spawnTask(options, config) {
     }
     await ensureDirectories(config);
     await checkDependencies();
-    await createWorktree(config, branchName, worktreePath);
-    // Build the prompt
-    let prompt = taskText;
+    if (options.resume) {
+        if (!existsSync(worktreePath)) {
+            fatal(`Cannot resume: worktree does not exist at ${worktreePath}`);
+        }
+        if (!existsSync(resolve(worktreePath, '.git'))) {
+            fatal(`Cannot resume: ${worktreePath} is not a valid git worktree`);
+        }
+        logger.info('Resuming existing worktree (skipping creation)');
+    }
+    else {
+        await createWorktree(config, branchName, worktreePath);
+    }
+    // Build the prompt — only include protocol if explicitly requested
+    let taskDescription = taskText;
     if (options.files && options.files.length > 0) {
-        prompt += `\n\nRelevant files to consider:\n${options.files.map(f => `- ${f}`).join('\n')}`;
+        taskDescription += `\n\nRelevant files to consider:\n${options.files.map(f => `- ${f}`).join('\n')}`;
+    }
+    const hasExplicitProtocol = options.protocol || options.useProtocol;
+    const resumeNotice = options.resume ? `\n${buildResumeNotice(builderId)}\n` : '';
+    let builderPrompt;
+    if (hasExplicitProtocol) {
+        const protocol = await resolveProtocol(options, config);
+        const protocolDef = loadProtocol(config, protocol);
+        const mode = resolveMode(options, protocolDef);
+        const templateContext = {
+            protocol_name: protocol.toUpperCase(),
+            mode,
+            mode_soft: mode === 'soft',
+            mode_strict: mode === 'strict',
+            project_id: builderId,
+            input_description: 'an ad-hoc task',
+            task_text: taskDescription,
+        };
+        const prompt = buildPromptFromTemplate(config, protocol, templateContext);
+        builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition.\n${resumeNotice}\n${prompt}`;
+    }
+    else {
+        builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition.
+${resumeNotice}
+# Task
+
+${taskDescription}`;
     }
-    const builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition. ${prompt}`;
     // Load role
     const role = options.noRole ? null : loadRolePrompt(config, 'builder');
     const commands = getResolvedCommands();
-    const { port, pid, sessionName } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
+    const { terminalId } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
     const builder = {
         id: builderId,
         name: `Task: ${taskText.substring(0, 30)}${taskText.length > 30 ? '...' : ''}`,
-        port,
-        pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'init',
         worktree: worktreePath,
         branch: branchName,
-        tmuxSession: sessionName,
         type: 'task',
         taskText,
+        terminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Builder ${builderId} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${terminalId}`);
 }
 /**
  * Spawn builder to run a protocol
@@ -470,36 +724,59 @@ async function spawnProtocol(options, config) {
     const builderId = `${protocolName}-${shortId}`;
     const branchName = `builder/${protocolName}-${shortId}`;
     const worktreePath = resolve(config.buildersDir, builderId);
-    logger.header(`Spawning Builder ${builderId} (protocol)`);
+    logger.header(`${options.resume ? 'Resuming' : 'Spawning'} Builder ${builderId} (protocol)`);
     logger.kv('Protocol', protocolName);
     logger.kv('Branch', branchName);
     logger.kv('Worktree', worktreePath);
     await ensureDirectories(config);
     await checkDependencies();
-    await createWorktree(config, branchName, worktreePath);
-    // Build the prompt
-    const prompt = `You are running the ${protocolName} protocol. Start by reading codev/protocols/${protocolName}/protocol.md and follow its instructions.`;
+    if (options.resume) {
+        if (!existsSync(worktreePath)) {
+            fatal(`Cannot resume: worktree does not exist at ${worktreePath}`);
+        }
+        if (!existsSync(resolve(worktreePath, '.git'))) {
+            fatal(`Cannot resume: ${worktreePath} is not a valid git worktree`);
+        }
+        logger.info('Resuming existing worktree (skipping creation)');
+    }
+    else {
+        await createWorktree(config, branchName, worktreePath);
+    }
+    // Load protocol definition and resolve mode
+    const protocolDef = loadProtocol(config, protocolName);
+    const mode = resolveMode(options, protocolDef);
+    logger.kv('Mode', mode.toUpperCase());
+    // Build the prompt using template
+    const templateContext = {
+        protocol_name: protocolName.toUpperCase(),
+        mode,
+        mode_soft: mode === 'soft',
+        mode_strict: mode === 'strict',
+        project_id: builderId,
+        input_description: `running the ${protocolName.toUpperCase()} protocol`,
+    };
+    const promptContent = buildPromptFromTemplate(config, protocolName, templateContext);
+    const resumeNotice = options.resume ? `\n${buildResumeNotice(builderId)}\n` : '';
+    const prompt = resumeNotice ? `${resumeNotice}\n${promptContent}` : promptContent;
     // Load protocol-specific role or fall back to builder role
     const role = options.noRole ? null : loadProtocolRole(config, protocolName);
     const commands = getResolvedCommands();
-    const { port, pid, sessionName } = await startBuilderSession(config, builderId, worktreePath, commands.builder, prompt, role?.content ?? null, role?.source ?? null);
+    const { terminalId } = await startBuilderSession(config, builderId, worktreePath, commands.builder, prompt, role?.content ?? null, role?.source ?? null);
     const builder = {
         id: builderId,
         name: `Protocol: ${protocolName}`,
-        port,
-        pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'init',
         worktree: worktreePath,
         branch: branchName,
-        tmuxSession: sessionName,
         type: 'protocol',
         protocolName,
+        terminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Builder ${builderId} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${terminalId}`);
 }
 /**
  * Spawn a bare shell session (no worktree, no prompt)
@@ -511,25 +788,23 @@ async function spawnShell(options, config) {
     await ensureDirectories(config);
     await checkDependencies();
     const commands = getResolvedCommands();
-    const { port, pid, sessionName } = await startShellSession(config, shortId, commands.builder);
+    const { terminalId } = await startShellSession(config, shortId, commands.builder);
     // Shell sessions are tracked as builders with type 'shell'
     // They don't have worktrees or branches
     const builder = {
         id: shellId,
         name: 'Shell session',
-        port,
-        pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'interactive',
         worktree: '',
         branch: '',
-        tmuxSession: sessionName,
         type: 'shell',
+        terminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Shell ${shellId} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${terminalId}`);
 }
 /**
  * Spawn a worktree session (has worktree/branch, but no initial prompt)
@@ -540,80 +815,77 @@ async function spawnWorktree(options, config) {
     const builderId = `worktree-${shortId}`;
     const branchName = `builder/worktree-${shortId}`;
     const worktreePath = resolve(config.buildersDir, builderId);
-    logger.header(`Spawning Worktree ${builderId}`);
+    logger.header(`${options.resume ? 'Resuming' : 'Spawning'} Worktree ${builderId}`);
     logger.kv('Branch', branchName);
     logger.kv('Worktree', worktreePath);
     await ensureDirectories(config);
     await checkDependencies();
-    await createWorktree(config, branchName, worktreePath);
+    if (options.resume) {
+        if (!existsSync(worktreePath)) {
+            fatal(`Cannot resume: worktree does not exist at ${worktreePath}`);
+        }
+        if (!existsSync(resolve(worktreePath, '.git'))) {
+            fatal(`Cannot resume: ${worktreePath} is not a valid git worktree`);
+        }
+        logger.info('Resuming existing worktree (skipping creation)');
+    }
+    else {
+        await createWorktree(config, branchName, worktreePath);
+    }
     // Load builder role
     const role = options.noRole ? null : loadRolePrompt(config, 'builder');
     const commands = getResolvedCommands();
     // Worktree mode: launch Claude with no prompt, but in the worktree directory
-    const port = await findFreePort(config);
-    const sessionName = getSessionName(config, builderId);
-    logger.info('Creating tmux session...');
+    logger.info('Creating terminal session...');
     // Build launch script (with role if provided) to avoid shell escaping issues
     const scriptPath = resolve(worktreePath, '.builder-start.sh');
     let scriptContent;
     if (role) {
         const roleFile = resolve(worktreePath, '.builder-role.md');
         // Inject the actual dashboard port into the role prompt
-        const roleWithPort = role.content.replace(/\{PORT\}/g, String(config.dashboardPort));
+        const roleWithPort = role.content.replace(/\{PORT\}/g, String(DEFAULT_TOWER_PORT));
         writeFileSync(roleFile, roleWithPort);
         logger.info(`Loaded role (${role.source})`);
         scriptContent = `#!/bin/bash
-exec ${commands.builder} --append-system-prompt "$(cat '${roleFile}')"
+cd "${worktreePath}"
+while true; do
+  ${commands.builder} --append-system-prompt "$(cat '${roleFile}')"
+  echo ""
+  echo "Claude exited. Restarting in 2 seconds... (Ctrl+C to quit)"
+  sleep 2
+done
 `;
     }
     else {
         scriptContent = `#!/bin/bash
-exec ${commands.builder}
+cd "${worktreePath}"
+while true; do
+  ${commands.builder}
+  echo ""
+  echo "Claude exited. Restarting in 2 seconds... (Ctrl+C to quit)"
+  sleep 2
+done
 `;
     }
     writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
-    // Create tmux session running the launch script
-    await run(`tmux new-session -d -s "${sessionName}" -x 200 -y 50 -c "${worktreePath}" "${scriptPath}"`);
-    await run(`tmux set-option -t "${sessionName}" status off`);
-    // Enable mouse scrolling in tmux
-    await run('tmux set -g mouse on');
-    await run('tmux set -g set-clipboard on');
-    await run('tmux set -g allow-passthrough on');
-    // Copy selection to clipboard when mouse is released (pbcopy for macOS)
-    await run('tmux bind-key -T copy-mode MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    await run('tmux bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"');
-    // Start ttyd connecting to the tmux session
-    logger.info('Starting worktree terminal...');
-    const customIndexPath = resolve(config.codevDir, 'templates', 'ttyd-index.html');
-    const hasCustomIndex = existsSync(customIndexPath);
-    if (hasCustomIndex) {
-        logger.info('Using custom terminal with file click support');
-    }
-    const ttydProcess = spawnTtyd({
-        port,
-        sessionName,
-        cwd: worktreePath,
-        customIndexPath: hasCustomIndex ? customIndexPath : undefined,
-    });
-    if (!ttydProcess?.pid) {
-        fatal('Failed to start ttyd process for worktree');
-    }
+    // Create PTY session via REST API
+    logger.info('Creating PTY terminal session for worktree...');
+    const { terminalId: worktreeTerminalId } = await createPtySession(config, '/bin/bash', [scriptPath], worktreePath, { projectPath: config.projectRoot, type: 'builder', roleId: builderId });
+    logger.info(`Worktree terminal session created: ${worktreeTerminalId}`);
     const builder = {
         id: builderId,
         name: 'Worktree session',
-        port,
-        pid: ttydProcess.pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'interactive',
         worktree: worktreePath,
         branch: branchName,
-        tmuxSession: sessionName,
         type: 'worktree',
+        terminalId: worktreeTerminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Worktree ${builderId} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${worktreeTerminalId}`);
 }
 /**
  * Generate a slug from an issue title (max 30 chars, lowercase, alphanumeric + hyphens)
@@ -688,7 +960,7 @@ async function checkBugfixCollisions(issueNumber, worktreePath, issue, force) {
  */
 async function spawnBugfix(options, config) {
     const issueNumber = options.issue;
-    logger.header(`Spawning Bugfix Builder for Issue #${issueNumber}`);
+    logger.header(`${options.resume ? 'Resuming' : 'Spawning'} Bugfix Builder for Issue #${issueNumber}`);
     // Fetch issue from GitHub
     logger.info('Fetching issue from GitHub...');
     const issue = await fetchGitHubIssue(issueNumber);
@@ -696,70 +968,95 @@ async function spawnBugfix(options, config) {
     const builderId = `bugfix-${issueNumber}`;
     const branchName = `builder/bugfix-${issueNumber}-${slug}`;
     const worktreePath = resolve(config.buildersDir, builderId);
+    // Resolve protocol (allows --use-protocol override)
+    const protocol = await resolveProtocol(options, config);
+    const protocolDef = loadProtocol(config, protocol);
+    // Resolve mode: --soft flag > protocol defaults > input type defaults (bugfix defaults to soft)
+    const mode = resolveMode(options, protocolDef);
     logger.kv('Title', issue.title);
     logger.kv('Branch', branchName);
     logger.kv('Worktree', worktreePath);
-    // Check for collisions
-    await checkBugfixCollisions(issueNumber, worktreePath, issue, !!options.force);
+    logger.kv('Protocol', protocol.toUpperCase());
+    logger.kv('Mode', mode.toUpperCase());
+    // Execute pre-spawn hooks from protocol.json (collision check, issue comment)
+    // Skip collision checks in resume mode — the worktree is expected to exist
+    if (!options.resume) {
+        if (protocolDef?.hooks?.['pre-spawn']) {
+            await executePreSpawnHooks(protocolDef, {
+                issueNumber,
+                issue,
+                worktreePath,
+                force: options.force,
+                noComment: options.noComment,
+            });
+        }
+        else {
+            // Fallback: hardcoded behavior for backwards compatibility
+            await checkBugfixCollisions(issueNumber, worktreePath, issue, !!options.force);
+            if (!options.noComment) {
+                logger.info('Commenting on issue...');
+                try {
+                    await run(`gh issue comment ${issueNumber} --body "On it! Working on a fix now."`);
+                }
+                catch {
+                    logger.warn('Warning: Failed to comment on issue (continuing anyway)');
+                }
+            }
+        }
+    }
     await ensureDirectories(config);
     await checkDependencies();
-    await createWorktree(config, branchName, worktreePath);
-    // Comment on the issue (unless --no-comment)
-    if (!options.noComment) {
-        logger.info('Commenting on issue...');
-        try {
-            await run(`gh issue comment ${issueNumber} --body "On it! Working on a fix now."`);
+    if (options.resume) {
+        if (!existsSync(worktreePath)) {
+            fatal(`Cannot resume: worktree does not exist at ${worktreePath}`);
         }
-        catch {
-            logger.warn('Warning: Failed to comment on issue (continuing anyway)');
+        if (!existsSync(resolve(worktreePath, '.git'))) {
+            fatal(`Cannot resume: ${worktreePath} is not a valid git worktree`);
         }
+        logger.info('Resuming existing worktree (skipping creation)');
     }
-    // Build the prompt with issue context
-    const prompt = `You are a Builder working on a BUGFIX task.
-
-## Protocol
-Follow the BUGFIX protocol: codev/protocols/bugfix/protocol.md
-
-## Issue #${issueNumber}
-**Title**: ${issue.title}
-
-**Description**:
-${issue.body || '(No description provided)'}
-
-## Your Mission
-1. Reproduce the bug
-2. Identify root cause
-3. Implement fix (< 300 LOC)
-4. Add regression test
-5. Run CMAP review (3-way parallel: Gemini, Codex, Claude)
-6. Create PR with "Fixes #${issueNumber}" in body
-
-If the fix is too complex (> 300 LOC or architectural changes), notify the Architect via:
-  af send architect "Issue #${issueNumber} is more complex than expected. [Reason]. Recommend escalating to SPIDER/TICK."
-
-Start by reading the issue and reproducing the bug.`;
-    const builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition.\n\n${prompt}`;
+    else {
+        await createWorktree(config, branchName, worktreePath);
+        // Pre-initialize porch so the builder doesn't need to figure out project ID
+        await initPorchInWorktree(worktreePath, protocol, builderId, slug);
+    }
+    // Build the prompt using template
+    const templateContext = {
+        protocol_name: protocol.toUpperCase(),
+        mode,
+        mode_soft: mode === 'soft',
+        mode_strict: mode === 'strict',
+        project_id: builderId,
+        input_description: `a fix for GitHub Issue #${issueNumber}`,
+        issue: {
+            number: issueNumber,
+            title: issue.title,
+            body: issue.body || '(No description provided)',
+        },
+    };
+    const prompt = buildPromptFromTemplate(config, protocol, templateContext);
+    const resumeNotice = options.resume ? `\n${buildResumeNotice(builderId)}\n` : '';
+    const builderPrompt = `You are a Builder. Read codev/roles/builder.md for your full role definition.\n${resumeNotice}\n${prompt}`;
     // Load role
     const role = options.noRole ? null : loadRolePrompt(config, 'builder');
     const commands = getResolvedCommands();
-    const { port, pid, sessionName } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
+    const { terminalId } = await startBuilderSession(config, builderId, worktreePath, commands.builder, builderPrompt, role?.content ?? null, role?.source ?? null);
     const builder = {
         id: builderId,
         name: `Bugfix #${issueNumber}: ${issue.title.substring(0, 40)}${issue.title.length > 40 ? '...' : ''}`,
-        port,
-        pid,
-        status: 'spawning',
+        status: 'implementing',
         phase: 'init',
         worktree: worktreePath,
         branch: branchName,
-        tmuxSession: sessionName,
         type: 'bugfix',
         issueNumber,
+        terminalId,
     };
     upsertBuilder(builder);
     logger.blank();
     logger.success(`Bugfix builder for issue #${issueNumber} spawned!`);
-    logger.kv('Terminal', `http://localhost:${port}`);
+    logger.kv('Mode', mode === 'strict' ? 'Strict (porch-driven)' : 'Soft (protocol-guided)');
+    logger.kv('Terminal', `ws://localhost:${DEFAULT_TOWER_PORT}/ws/terminal/${terminalId}`);
 }
 // =============================================================================
 // Main entry point
@@ -770,6 +1067,25 @@ Start by reading the issue and reproducing the bug.`;
 export async function spawn(options) {
     validateSpawnOptions(options);
     const config = getConfig();
+    // Refuse to spawn if the main worktree has uncommitted changes.
+    // Builders work in git worktrees branched from HEAD — uncommitted changes
+    // (specs, plans, codev updates) won't be visible to the builder.
+    // Skip this check in resume mode — the worktree already exists with its own branch.
+    if (!options.force && !options.resume) {
+        try {
+            const { stdout } = await run('git status --porcelain', { cwd: config.projectRoot });
+            if (stdout.trim().length > 0) {
+                fatal('Uncommitted changes detected in main worktree.\n\n' +
+                    '  Builders branch from HEAD, so uncommitted files (specs, plans,\n' +
+                    '  codev updates) will NOT be visible to the builder.\n\n' +
+                    '  Please commit or stash your changes first, then retry.\n' +
+                    '  Use --force to skip this check.');
+            }
+        }
+        catch {
+            // Non-fatal — if git status fails, allow spawn to continue
+        }
+    }
     // Prune stale worktrees before spawning to prevent "can't find session" errors
     // This catches orphaned worktrees from crashes, manual kills, or incomplete cleanups
     try {