@dsiloed/silo-link 1.3.0 → 1.5.0

package/dist/core/claude-launcher.js

@@ -1,4 +1,6 @@
-import { spawn } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
+import jwt from 'jsonwebtoken';
+import { BaseTmuxLauncher } from './base-tmux-launcher.js';
 /**
  * Claude Code implementation of the AgentLauncher interface.
  *
@@ -9,226 +11,170 @@ import { spawn } from 'node:child_process';
  * - Store Claude session ID in DSiloed agent_session metadata
  * - Kill all child processes on SiloLink shutdown
  */
-export class ClaudeLauncher {
-    config;
-    sessionManager;
-    dsiloedClient;
-    workspaceManager;
+export class ClaudeLauncher extends BaseTmuxLauncher {
     childProcess = null;
-    tmuxSessions = new Map(); // tmuxName -> conversationId
-    tmuxSessionWorkspaces = new Map(); // tmuxName -> sessionId (for worktree cleanup)
-    tmuxMonitorTimer = null;
-    idleCheckTimer = null;
-    launchingConversations = new Set();
-    messageQueue = null;
-    enabled;
-    lastNudgeAt = 0;
-    nudgeCount = 0; // Consecutive nudges without activity change
-    lastActivitySnapshot = new Map(); // sessionId -> lastActivity timestamp
-    // Last Claude Code session ID (for --resume)
-    lastClaudeSessionId = null;
-    // Message that triggered the current launch (included in prompt for context)
-    pendingTriggerMessage = null;
-    // Workspace config for the next launch (set by control channel or API)
-    pendingWorkspaceConfig = null;
-    // Override CWD for next launch (used when re-launching into an existing worktree)
-    pendingWorkspaceCwd = null;
     constructor(config, sessionManager, dsiloedClient, messageQueue, workspaceManager) {
-        this.config = config;
-        this.sessionManager = sessionManager;
-        this.dsiloedClient = dsiloedClient || null;
-        this.messageQueue = messageQueue || null;
-        this.workspaceManager = workspaceManager || null;
-        this.enabled = !!(config.claude_command && config.claude_working_directory);
+        super(config, sessionManager, dsiloedClient, messageQueue, workspaceManager);
     }
-    isEnabled() {
-        return this.enabled;
+    // --- Abstract implementation ---
+    getCommand() {
+        return this.config.claude_command || 'claude';
     }
-    isAutoRespawnEnabled() {
-        return this.enabled && !!this.config.claude_auto_respawn;
+    getArgs() {
+        return ['--dangerously-skip-permissions'];
     }
-    hasLiveProcess() {
-        return this.tmuxSessions.size > 0;
+    getReadyIndicator() {
+        return ['❯'];
     }
-    getLastClaudeSessionId() {
-        return this.lastClaudeSessionId;
-    }
-    setLastResumeId(resumeId) {
-        this.lastClaudeSessionId = resumeId;
-        console.log(`[ClaudeLauncher] Restored resume ID from previous session: ${resumeId}`);
+    /** Wait 5s before checking — Claude Code shows ❯ in its welcome screen before it's ready */
+    getMinReadyWaitMs() { return 5000; }
+    /** Wait 3s after ready for npx mcp-remote servers to finish connecting */
+    getPostReadyDelayMs() { return 3000; }
+    formatPrompt(prompt) {
+        return prompt;
     }
-    /**
-     * Start the idle monitor that nudges idle sessions or respawns dead ones.
-     */
-    startIdleMonitor() {
-        if (!this.isAutoRespawnEnabled())
-            return;
-        const checkInterval = Math.max((this.config.claude_idle_timeout_ms || 30000) / 2, 5000);
-        this.idleCheckTimer = setInterval(() => this.checkIdle(), checkInterval);
-        console.log(`  Claude auto-manage enabled (idle timeout: ${this.config.claude_idle_timeout_ms || 30000}ms)`);
-    }
-    stopIdleMonitor() {
-        if (this.idleCheckTimer) {
-            clearInterval(this.idleCheckTimer);
-            this.idleCheckTimer = null;
-        }
-    }
-    /**
-     * Launch a new Claude Code session. Uses --resume if a previous session ID is available.
-     * This is the internal launch method — use launchAgent() for the AgentLauncher interface.
-     */
-    async launchInternal(reason = 'manual', conversationId) {
-        if (!this.enabled) {
-            console.log('[ClaudeLauncher] Not configured — set claude_command and claude_working_directory in config');
-            return false;
-        }
-        const convKey = conversationId || 0;
-        if (this.launchingConversations.has(convKey)) {
-            console.log(`[ClaudeLauncher] Already launching for conversation ${convKey}, skipping`);
-            return false;
+    async setupMcpConfig(cwd, toolAllowlist) {
+        // Generate a JWT for the dsiloed MCP server
+        const token = jwt.sign({
+            sub: this.config.user_sub,
+            iat: Math.floor(Date.now() / 1000),
+            tenant_enterprise_identifier: this.config.tenant_id,
+        }, this.config.shared_key, { algorithm: 'HS256', expiresIn: '24h' });
+        // Build the dsiloed MCP URL pointing to the same server SiloLink connects to
+        let dsiloedUrl = `${this.config.host}/api/v1/mcp?categories=data,admin,conversation,utility`;
+        if (toolAllowlist && toolAllowlist.length > 0) {
+            const url = new URL(`${this.config.host}/api/v1/mcp`);
+            url.searchParams.set('tools', toolAllowlist.join(','));
+            dsiloedUrl = url.toString();
         }
-        this.launchingConversations.add(convKey);
-        try {
-            const command = this.config.claude_command || 'claude';
-            let cwd = this.config.claude_working_directory || process.cwd();
-            const args = ['--dangerously-skip-permissions'];
-            // Create a worktree if workspace config is provided
-            let workspaceSessionId = null;
-            let workspaceBranch = null;
-            const wsConfig = this.pendingWorkspaceConfig;
-            this.pendingWorkspaceConfig = null;
-            if (wsConfig && this.workspaceManager) {
-                // Use a temporary session ID for the worktree (will be updated when Claude registers)
-                workspaceSessionId = `tmux-${Date.now()}`;
-                workspaceBranch = wsConfig.branch;
+        // Register MCP servers via `claude mcp add` (project scope for the target CWD).
+        // This is the official API — works across Claude Code versions and doesn't
+        // require interactive approval when launched with --dangerously-skip-permissions.
+        const servers = [
+            {
+                name: 'silolink',
+                args: ['--', 'npx', 'mcp-remote', `http://localhost:${this.config.mcp_port}/mcp`],
+            },
+            {
+                name: 'silolink_server',
+                args: [
+                    '--', 'npx', 'mcp-remote', dsiloedUrl,
+                    '--header', `Authorization: Bearer ${token}`,
+                    '--header', `Tenant-Id: ${this.config.tenant_id}`,
+                ],
+            },
+        ];
+        for (const server of servers) {
+            try {
+                execFileSync('claude', ['mcp', 'add', '-s', 'user', server.name, ...server.args], {
+                    cwd,
+                    stdio: 'pipe',
+                    timeout: 10000,
+                });
+            }
+            catch {
+                // Server may already exist at user or project scope — remove both and re-add at user scope
                 try {
-                    const workspace = this.workspaceManager.createWorktree(workspaceSessionId, wsConfig.repoPath, wsConfig.branch, wsConfig.baseBranch || 'development');
-                    cwd = workspace.worktreePath;
-                    console.log(`[ClaudeLauncher] Created worktree at ${cwd} (branch: ${wsConfig.branch})`);
+                    try {
+                        execFileSync('claude', ['mcp', 'remove', '-s', 'user', server.name], { cwd, stdio: 'pipe', timeout: 5000 });
+                    }
+                    catch { /* may not exist */ }
+                    try {
+                        execFileSync('claude', ['mcp', 'remove', '-s', 'project', server.name], { cwd, stdio: 'pipe', timeout: 5000 });
+                    }
+                    catch { /* may not exist */ }
+                    execFileSync('claude', ['mcp', 'add', '-s', 'user', server.name, ...server.args], {
+                        cwd,
+                        stdio: 'pipe',
+                        timeout: 10000,
+                    });
                 }
                 catch (err) {
-                    console.error(`[ClaudeLauncher] Failed to create worktree: ${err}`);
-                    // Fall back to normal cwd
-                    workspaceSessionId = null;
-                    workspaceBranch = null;
-                }
-            }
-            // Use existing worktree CWD if set (re-launching into a linked workspace)
-            const existingWorkspaceCwd = this.pendingWorkspaceCwd;
-            this.pendingWorkspaceCwd = null;
-            if (existingWorkspaceCwd && !workspaceSessionId) {
-                cwd = existingWorkspaceCwd;
-                console.log(`[ClaudeLauncher] Using existing worktree at ${cwd}`);
-            }
-            let prompt;
-            // Build workspace context string for inclusion in prompts
-            const workspaceContext = (workspaceSessionId || existingWorkspaceCwd)
-                ? `\n\nWORKSPACE: You are working in an isolated git worktree at "${cwd}". This is separate from the main repo — your changes won't affect other sessions. Use remote_workspace_claim to claim files before editing, and remote_workspace_check to see what other sessions are working on.`
-                : '';
-            // Try to resume previous session if we have an ID
-            if (this.lastClaudeSessionId && (reason === 'process-exit' || reason === 'inbound-message')) {
-                args.push('--resume', this.lastClaudeSessionId);
-                console.log(`[ClaudeLauncher] Resuming session: ${this.lastClaudeSessionId}`);
-                prompt = 'Continue polling SiloLink for messages. Check memory for context if needed.' + workspaceContext;
-            }
-            else {
-                if (reason === 'process-exit' || reason === 'inbound-message') {
-                    const registerParams = conversationId
-                        ? `{ "conversation_id": ${conversationId} }`
-                        : `{}`;
-                    const triggerLine = this.pendingTriggerMessage
-                        ? `\n\nThe user's latest message (which triggered this session restart): "${this.pendingTriggerMessage}"\nAddress this message AFTER loading context. Do NOT ask the user to repeat themselves.`
-                        : '';
-                    this.pendingTriggerMessage = null;
-                    prompt = [
-                        `Call mcp__silolink__remote_register with these exact parameters: ${registerParams}. After registering, call remote_load_context() to load the prior conversation history. Review all returned messages to understand what was discussed. Then send a remote_notify telling the user you are continuing where the last session left off. Then enter the poll loop using remote_poll. See CLAUDE.md for the poll loop pattern.`,
-                        '',
-                        'Context: This is a new session replacing a previous one that ended.',
-                        'Before entering the poll loop:',
-                        '1. Call remote_load_context() and review the conversation history',
-                        '2. Check your memory files for additional context on recent work',
-                        '3. Send a remote_notify summarizing what you loaded and confirming you are ready',
-                        '4. Process the user\'s pending message (if any) before entering the poll loop',
-                        '',
-                        'CRITICAL: The user is NOT watching the terminal. You MUST send a remote_notify progress update after EVERY major step (file edits, commits, merges, deploys, errors). Do not go silent while working.',
-                        triggerLine,
-                        workspaceContext,
-                    ].join('\n');
-                }
-                else {
-                    prompt = (this.config.claude_session_prompt ||
-                        'Register with SiloLink as "portablemind" and enter the poll loop.') + workspaceContext;
+                    console.error(`[ClaudeLauncher] Failed to register MCP server '${server.name}': ${err}`);
                 }
             }
-            console.log(`[ClaudeLauncher] Launching Claude Code via tmux (reason: ${reason})`);
-            console.log(`  Command: ${command} ${args.join(' ')}`);
-            console.log(`  Working directory: ${cwd}`);
-            if (workspaceBranch)
-                console.log(`  Workspace branch: ${workspaceBranch}`);
-            console.log(`  Prompt: ${prompt.substring(0, 100)}...`);
-            const tmuxSession = `silolink-claude-${Date.now()}`;
-            // Create a new tmux session running Claude Code in a real TTY
-            const claudeCmd = `cd ${cwd} && ${command} ${args.join(' ')}`;
-            const tmuxCreate = spawn('tmux', [
-                'new-session', '-d', '-s', tmuxSession, '-x', '200', '-y', '50', claudeCmd,
-            ], {
-                stdio: 'ignore',
-                detached: true,
-                env: {
-                    ...process.env,
-                    SILOLINK_MCP_URL: `http://localhost:${this.config.mcp_port}/mcp`,
-                },
-            });
-            tmuxCreate.unref();
-            // Wait for tmux session to start, then send the prompt
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            // Check if tmux session exists
-            const checkResult = spawn('tmux', ['has-session', '-t', tmuxSession], { stdio: 'ignore' });
-            const sessionExists = await new Promise(resolve => {
-                checkResult.on('exit', code => resolve(code === 0));
-            });
-            if (!sessionExists) {
-                console.error(`[ClaudeLauncher] tmux session ${tmuxSession} failed to start`);
-                // Clean up worktree if we created one
-                if (workspaceSessionId && this.workspaceManager) {
-                    this.workspaceManager.removeWorktree(workspaceSessionId);
-                }
-                return false;
-            }
-            console.log(`[ClaudeLauncher] tmux session "${tmuxSession}" created`);
-            this.tmuxSessions.set(tmuxSession, conversationId || 0);
-            if (workspaceSessionId) {
-                this.tmuxSessionWorkspaces.set(tmuxSession, workspaceSessionId);
-            }
-            // Send the prompt to Claude via tmux send-keys after MCP servers initialize
-            const sessionToPrompt = tmuxSession;
-            const promptToSend = prompt;
-            setTimeout(() => {
-                const escapedPrompt = promptToSend.replace(/"/g, '\\"').replace(/\n/g, ' ');
-                const sendKeys = spawn('tmux', ['send-keys', '-t', sessionToPrompt, escapedPrompt], { stdio: 'pipe' });
-                sendKeys.on('exit', (code) => {
-                    if (code === 0) {
-                        console.log(`[ClaudeLauncher] Sent prompt to tmux session "${sessionToPrompt}" (${promptToSend.length} chars)`);
-                        // Send Enter separately after a short delay to avoid bracketed paste swallowing it
-                        setTimeout(() => {
-                            spawn('tmux', ['send-keys', '-t', sessionToPrompt, 'Enter'], { stdio: 'pipe' });
-                        }, 500);
-                    }
-                    else {
-                        console.error(`[ClaudeLauncher] Failed to send prompt to tmux session "${sessionToPrompt}" (exit code: ${code})`);
-                    }
-                });
-                sendKeys.on('error', (err) => {
-                    console.error(`[ClaudeLauncher] Error sending prompt to "${sessionToPrompt}": ${err.message}`);
-                });
-            }, 8000); // Wait 8s for MCP to initialize
-            // Monitor the tmux session for exit
-            this.monitorTmuxSession(tmuxSession);
-            return true;
         }
-        finally {
-            setTimeout(() => { this.launchingConversations.delete(convKey); }, 10000);
+        console.log(`[ClaudeLauncher] Registered MCP servers for ${cwd} (host: ${this.config.host})`);
+    }
+    checkEnabled() {
+        return !!(this.config.claude_command && this.config.projects_path);
+    }
+    getWorkingDirectory() {
+        return this.config.projects_path || process.cwd();
+    }
+    isAutoRespawnConfigured() {
+        return !!this.config.claude_auto_respawn;
+    }
+    getIdleTimeoutMs() {
+        return this.config.claude_idle_timeout_ms || 30000;
+    }
+    getSessionPrompt() {
+        return this.config.claude_session_prompt;
+    }
+    getAgentEnv() {
+        return {
+            SILOLINK_MCP_URL: `http://localhost:${this.config.mcp_port}/mcp`,
+            SILOLINK_AGENT_PROVIDER: 'claude',
+        };
+    }
+    getTmuxPrefix() {
+        return 'silolink-claude';
+    }
+    getLogTag() {
+        return '[ClaudeLauncher]';
+    }
+    getCostMetadataKey() {
+        return 'claude_code_cost_usd';
+    }
+    buildLaunchPrompt(reason, conversationId, agentContext, workspaceContext) {
+        const extraArgs = [];
+        if (this.lastSessionId && (reason === 'process-exit' || reason === 'inbound-message')) {
+            extraArgs.push('--resume', this.lastSessionId);
+            return {
+                prompt: 'Continue polling SiloLink for messages. Check memory for context if needed.' + workspaceContext,
+                extraArgs,
+            };
+        }
+        if (reason === 'process-exit' || reason === 'inbound-message') {
+            const agentIdParam = this.pendingLlmAgentId
+                ? `, "llm_agent_id": ${this.pendingLlmAgentId}`
+                : '';
+            const registerParams = conversationId
+                ? `{ "conversation_id": ${conversationId}${agentIdParam} }`
+                : `{${agentIdParam ? agentIdParam.substring(2) : ''}}`;
+            this.pendingLlmAgentId = null;
+            const triggerLine = this.pendingTriggerMessage
+                ? `\n\nThe user's latest message (which triggered this session restart): "${this.pendingTriggerMessage}"\nAddress this message AFTER loading context. Do NOT ask the user to repeat themselves.`
+                : '';
+            this.pendingTriggerMessage = null;
+            return {
+                prompt: [
+                    `Call mcp__silolink__remote_register with these exact parameters: ${registerParams}. After registering, call remote_load_context() to load the prior conversation history. Review all returned messages to understand what was discussed. Then send a remote_notify telling the user you are continuing where the last session left off. Then enter the poll loop using remote_poll. See CLAUDE.md for the poll loop pattern.`,
+                    '',
+                    'Context: This is a new session replacing a previous one that ended.',
+                    'Before entering the poll loop:',
+                    '1. Call remote_load_context() and review the conversation history',
+                    '2. Check your memory files for additional context on recent work',
+                    '3. Send a remote_notify summarizing what you loaded and confirming you are ready',
+                    '4. Process the user\'s pending message (if any) before entering the poll loop',
+                    '',
+                    'CRITICAL: The user is NOT watching the terminal. You MUST send a remote_notify progress update after EVERY major step (file edits, commits, merges, deploys, errors). Do not go silent while working.',
+                    triggerLine,
+                    agentContext,
+                    workspaceContext,
+                ].join('\n'),
+                extraArgs,
+            };
         }
+        return {
+            prompt: (this.config.claude_session_prompt ||
+                'Register with SiloLink as "portablemind" and enter the poll loop.') + agentContext + workspaceContext,
+            extraArgs,
+        };
+    }
+    // --- Claude-specific additions ---
+    getLastClaudeSessionId() {
+        return this.lastSessionId;
     }
     /**
      * Store the Claude resume ID in the DSiloed agent session metadata.
@@ -248,64 +194,21 @@ export class ClaudeLauncher {
         }
     }
     /**
-     * Set workspace configuration for the next launch.
-     * The worktree will be created when launch() is called.
-     */
-    setWorkspaceConfig(config) {
-        this.pendingWorkspaceConfig = config;
-    }
-    /**
-     * Called when an inbound message arrives and no active session can handle it.
-     * @param triggerMessage - Content of the message that triggered the launch (included in prompt)
-     */
-    async launchOnMessage(conversationId, triggerMessage) {
-        if (!this.enabled)
-            return false;
-        // Check if there's already a session registered for this conversation
-        if (conversationId) {
-            const existingSession = this.sessionManager.getByConversationId(conversationId);
-            if (existingSession) {
-                console.log(`[ClaudeLauncher] Session already exists for conversation ${conversationId} — skipping`);
-                return false;
-            }
-        }
-        // Store trigger message so the launch prompt can include it
-        this.pendingTriggerMessage = triggerMessage || null;
-        // If a workspace is linked to this conversation, set it as pending so
-        // launchInternal creates the session in the correct worktree directory.
-        if (conversationId && this.workspaceManager) {
-            const workspace = this.workspaceManager.getByConversationId(conversationId);
-            if (workspace) {
-                console.log(`[ClaudeLauncher] Found linked workspace for conv=${conversationId}: ${workspace.branch}`);
-                // Don't create a new worktree — just set CWD to existing one.
-                // We skip setWorkspaceConfig to avoid re-creating the worktree.
-                // Instead, override the working directory directly for this launch.
-                this.pendingWorkspaceCwd = workspace.worktreePath;
-            }
-        }
-        return this.launchInternal('inbound-message', conversationId);
-    }
-    /**
-     * Check for idle sessions — nudge if process alive, respawn if dead.
-     * If a session has been nudged multiple times without responding and has
-     * pending messages, kill and relaunch it (hung session recovery).
+     * Extended idle checking with Claude-specific hung session recovery.
      */
     async checkIdle() {
         const sessions = this.sessionManager.getAll();
-        const idleTimeout = this.config.claude_idle_timeout_ms || 30000;
-        const maxNudges = 10; // Kill after 10 failed nudges (~5 min with no response)
+        const idleTimeout = this.getIdleTimeoutMs();
+        const maxNudges = 10;
         const now = Date.now();
         if (sessions.length === 0)
             return;
-        // Don't nudge sessions that were just created — give them time to
-        // process the launch prompt and initial messages before intervening.
-        const startupGracePeriod = 90000; // 90 seconds
+        const startupGracePeriod = 90000;
         const allPastStartup = sessions.every(s => now - s.createdAt.getTime() > startupGracePeriod);
         if (!allPastStartup)
             return;
         const allIdle = sessions.every(s => now - s.lastActivity.getTime() > idleTimeout);
         if (!allIdle) {
-            // Activity detected — reset nudge counter and update snapshots
             this.nudgeCount = 0;
             for (const s of sessions) {
                 this.lastActivitySnapshot.set(s.sessionId, s.lastActivity.getTime());
@@ -313,7 +216,6 @@ export class ClaudeLauncher {
             return;
         }
         if (this.hasLiveProcess()) {
-            // Check if activity changed since last nudge
             const activityChanged = sessions.some(s => {
                 const prev = this.lastActivitySnapshot.get(s.sessionId) || 0;
                 return s.lastActivity.getTime() > prev;
@@ -321,15 +223,11 @@ export class ClaudeLauncher {
             if (activityChanged) {
                 this.nudgeCount = 0;
             }
-            // Update snapshots
             for (const s of sessions) {
                 this.lastActivitySnapshot.set(s.sessionId, s.lastActivity.getTime());
             }
-            // Check if any session has messages that haven't been delivered yet.
-            // Messages already polled by Claude (pending ack) don't count — Claude is working on them.
             const hasUndelivered = this.messageQueue && sessions.some(s => this.messageQueue.hasUndeliveredMessages(s.sessionId));
             if (this.nudgeCount >= maxNudges && hasUndelivered) {
-                // Session is hung with undelivered messages — kill and relaunch
                 console.log(`[ClaudeLauncher] Session hung (${this.nudgeCount} nudges with no response, undelivered messages) — killing and relaunching`);
                 const hungSessions = sessions.filter(s => this.messageQueue.hasUndeliveredMessages(s.sessionId));
                 for (const s of hungSessions) {
@@ -338,36 +236,28 @@ export class ClaudeLauncher {
                         this.messageQueue.clearSession(s.sessionId);
                     }
                     this.sessionManager.unregister(s.sessionId);
-                    // Wait for tmux kill to complete before relaunching
                     await new Promise(resolve => setTimeout(resolve, 2000));
                     await this.launchInternal('inbound-message', s.conversationId);
                 }
                 this.nudgeCount = 0;
                 return;
             }
-            // Kill zombie sessions — only if a session hasn't made any MCP tool call in 10 minutes
-            // AND has undelivered messages waiting. A session doing non-MCP work (file edits, bash
-            // commands, etc.) is not a zombie — it's just not using SiloLink tools.
-            const zombieTimeout = 10 * 60 * 1000; // 10 minutes
+            const zombieTimeout = 10 * 60 * 1000;
             const zombieSessions = sessions.filter(s => now - s.lastActivity.getTime() > zombieTimeout &&
                 this.messageQueue?.hasUndeliveredMessages(s.sessionId));
             for (const s of zombieSessions) {
                 console.log(`[ClaudeLauncher] Zombie session detected (no MCP activity for ${Math.round((now - s.lastActivity.getTime()) / 60000)}min, has undelivered messages) — killing conv=${s.conversationId}`);
                 this.killByConversation(s.conversationId);
-                // Clear queue before unregister so messages can be re-buffered on relaunch
                 if (this.messageQueue) {
                     this.messageQueue.clearSession(s.sessionId);
                 }
                 this.sessionManager.unregister(s.sessionId);
-                // Wait for tmux kill to complete before relaunching
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 console.log(`[ClaudeLauncher] Relaunching for conversation ${s.conversationId} after zombie cleanup`);
                 this.launchInternal('inbound-message', s.conversationId).catch(err => {
                     console.error(`[ClaudeLauncher] Relaunch after zombie kill failed: ${err}`);
                 });
             }
-            // Only nudge if there are messages waiting — no point nudging an idle session
-            // that's already polling with nothing to do
             if (hasUndelivered) {
                 this.nudge();
                 this.nudgeCount++;
@@ -375,241 +265,28 @@ export class ClaudeLauncher {
             return;
         }
         else if (this.launchingConversations.size === 0) {
-            // Process is dead — clean up orphaned sessions instead of auto-respawning.
-            // New sessions will be launched on-demand when inbound messages arrive
-            // (handled by SubscriptionManager.handleCableMessage → launchOnMessage).
             console.log(`[ClaudeLauncher] Sessions orphaned (process dead) — cleaning up ${sessions.length} session(s). Will relaunch on next inbound message.`);
             for (const s of sessions) {
-                if (!this.lastClaudeSessionId && s.claudeResumeId) {
-                    this.lastClaudeSessionId = s.claudeResumeId;
+                if (!this.lastSessionId && s.claudeResumeId) {
+                    this.lastSessionId = s.claudeResumeId;
                 }
                 this.sessionManager.unregister(s.sessionId);
             }
             this.nudgeCount = 0;
         }
     }
-    /**
-     * Monitor a tmux session and detect when it exits.
-     */
-    monitorTmuxSession(sessionName) {
-        // Start monitor if not already running
-        if (!this.tmuxMonitorTimer) {
-            this.tmuxMonitorTimer = setInterval(() => this.checkTmuxSessions(), 5000);
-        }
-    }
-    checkTmuxSessions() {
-        for (const [name] of this.tmuxSessions) {
-            const check = spawn('tmux', ['has-session', '-t', name], { stdio: 'ignore' });
-            check.on('exit', (code) => {
-                if (code !== 0) {
-                    console.log(`[ClaudeLauncher] tmux session "${name}" ended`);
-                    // Clean up worktree if this session had one
-                    const wsSessionId = this.tmuxSessionWorkspaces.get(name);
-                    if (wsSessionId && this.workspaceManager) {
-                        console.log(`[ClaudeLauncher] Cleaning up worktree for workspace session ${wsSessionId}`);
-                        this.workspaceManager.removeWorktree(wsSessionId);
-                        this.tmuxSessionWorkspaces.delete(name);
-                    }
-                    this.tmuxSessions.delete(name);
-                    if (this.tmuxSessions.size === 0 && this.tmuxMonitorTimer) {
-                        clearInterval(this.tmuxMonitorTimer);
-                        this.tmuxMonitorTimer = null;
-                    }
-                }
-            });
-        }
-    }
-    /**
-     * Send a message to all running Claude sessions via tmux send-keys.
-     */
-    nudge() {
-        if (this.tmuxSessions.size === 0)
-            return false;
-        const now = Date.now();
-        // Exponential backoff: 30s, 60s, 120s, 240s, ... (capped at 5 min)
-        const baseInterval = 30000;
-        const interval = Math.min(baseInterval * Math.pow(2, this.nudgeCount), 5 * 60 * 1000);
-        if (now - this.lastNudgeAt < interval)
-            return false;
-        this.lastNudgeAt = now;
-        const message = 'Continue polling SiloLink for messages. Do not stop the poll loop.';
-        for (const [name] of this.tmuxSessions) {
-            spawn('tmux', ['send-keys', '-t', name, message, 'Enter'], { stdio: 'ignore' });
-        }
-        console.log(`[ClaudeLauncher] Nudged ${this.tmuxSessions.size} Claude session(s) via tmux (attempt ${this.nudgeCount + 1}, next in ${Math.round(interval / 1000)}s)`);
-        return true;
-    }
-    /**
-     * Interrupt the Claude session for a specific conversation.
-     * Sends Escape to stop current work, then redirects Claude to check
-     * for new messages via remote_poll.
-     */
-    async interrupt(conversationId, message) {
-        for (const [name, convId] of this.tmuxSessions) {
-            if (convId === conversationId) {
-                console.log(`[ClaudeLauncher] Interrupting tmux session "${name}" (conversation ${conversationId})`);
-                // Send Escape to interrupt current work
-                spawn('tmux', ['send-keys', '-t', name, 'Escape'], { stdio: 'ignore' });
-                // Wait for Claude to stop
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                // Tell Claude to check for the new message
-                const redirect = message
-                    || 'The user interrupted you. Check remote_poll for their latest message and follow those instructions instead.';
-                const escapedRedirect = redirect.replace(/"/g, '\\"').replace(/\n/g, ' ');
-                spawn('tmux', ['send-keys', '-t', name, escapedRedirect], { stdio: 'ignore' });
-                await new Promise(resolve => setTimeout(resolve, 500));
-                spawn('tmux', ['send-keys', '-t', name, 'Enter'], { stdio: 'ignore' });
-                console.log(`[ClaudeLauncher] Interrupt sent to "${name}"`);
-                return true;
-            }
-        }
-        console.log(`[ClaudeLauncher] No tmux session found for conversation ${conversationId} to interrupt`);
-        return false;
-    }
-    /**
-     * Kill the Claude session for a specific conversation.
-     */
-    killByConversation(conversationId) {
-        for (const [name, convId] of this.tmuxSessions) {
-            if (convId === conversationId) {
-                console.log(`[ClaudeLauncher] Killing tmux session "${name}" (conversation ${conversationId})`);
-                // Clean up worktree
-                const wsSessionId = this.tmuxSessionWorkspaces.get(name);
-                if (wsSessionId && this.workspaceManager) {
-                    this.workspaceManager.removeWorktree(wsSessionId);
-                    this.tmuxSessionWorkspaces.delete(name);
-                }
-                spawn('tmux', ['kill-session', '-t', name], { stdio: 'ignore' });
-                this.tmuxSessions.delete(name);
-                return;
-            }
-        }
-        console.log(`[ClaudeLauncher] No tmux session found for conversation ${conversationId}`);
-    }
-    /**
-     * Kill all running Claude Code sessions.
-     */
     kill() {
-        for (const [name] of this.tmuxSessions) {
-            console.log(`[ClaudeLauncher] Killing tmux session "${name}"`);
-            // Clean up worktree
-            const wsSessionId = this.tmuxSessionWorkspaces.get(name);
-            if (wsSessionId && this.workspaceManager) {
-                this.workspaceManager.removeWorktree(wsSessionId);
-            }
-            spawn('tmux', ['kill-session', '-t', name], { stdio: 'ignore' });
-        }
-        this.tmuxSessions.clear();
-        this.tmuxSessionWorkspaces.clear();
-        if (this.tmuxMonitorTimer) {
-            clearInterval(this.tmuxMonitorTimer);
-            this.tmuxMonitorTimer = null;
-        }
+        super.kill();
         if (this.childProcess) {
             this.childProcess.kill('SIGTERM');
             this.childProcess = null;
         }
     }
-    // ---- AgentLauncher interface methods ----
-    /**
-     * Launch a new agent process (AgentLauncher interface).
-     */
-    async launch(config) {
-        if (config.workspace) {
-            this.setWorkspaceConfig(config.workspace);
-        }
-        if (config.triggerMessage) {
-            this.pendingTriggerMessage = config.triggerMessage;
-        }
-        if (config.sessionPrompt) {
-            this.config.claude_session_prompt = config.sessionPrompt;
-        }
-        const success = await this.launchInternal(config.reason, config.conversationId);
-        if (!success)
-            return null;
-        // Find the process we just created (most recent tmux session)
-        const entries = Array.from(this.tmuxSessions.entries());
-        const latest = entries[entries.length - 1];
-        if (!latest)
-            return null;
-        const [processId, conversationId] = latest;
-        const wsSessionId = this.tmuxSessionWorkspaces.get(processId);
-        return {
-            processId,
-            conversationId,
-            workingDirectory: this.config.claude_working_directory || process.cwd(),
-            branch: config.workspace?.branch,
-            workspaceSessionId: wsSessionId || undefined,
-            startedAt: new Date(),
-        };
-    }
-    /**
-     * Resume a previous session by ID.
-     */
-    async resume(resumeId, config) {
-        this.setLastResumeId(resumeId);
-        return this.launch({ ...config, reason: 'process-exit' });
-    }
-    /**
-     * Check if a specific process is still alive.
-     */
-    async isAlive(process) {
-        return new Promise(resolve => {
-            const check = spawn('tmux', ['has-session', '-t', process.processId], { stdio: 'ignore' });
-            check.on('exit', code => resolve(code === 0));
-            check.on('error', () => resolve(false));
-        });
-    }
-    /**
-     * Terminate a specific agent process.
-     */
-    terminate(process) {
-        this.killByConversation(process.conversationId);
-    }
-    /**
-     * Terminate all managed agent processes.
-     */
-    terminateAll() {
-        this.kill();
-    }
-    /**
-     * Get all currently running agent processes.
-     */
-    getProcesses() {
-        const processes = [];
-        for (const [processId, conversationId] of this.tmuxSessions) {
-            const wsSessionId = this.tmuxSessionWorkspaces.get(processId);
-            processes.push({
-                processId,
-                conversationId,
-                workingDirectory: this.config.claude_working_directory || process.cwd(),
-                workspaceSessionId: wsSessionId,
-                startedAt: new Date(), // Approximate — we don't track exact start time per tmux session
-            });
-        }
-        return processes;
-    }
-    /**
-     * Get the process handling a specific conversation.
-     */
-    getByConversation(conversationId) {
-        for (const [processId, convId] of this.tmuxSessions) {
-            if (convId === conversationId) {
-                const wsSessionId = this.tmuxSessionWorkspaces.get(processId);
-                return {
-                    processId,
-                    conversationId,
-                    workingDirectory: this.config.claude_working_directory || process.cwd(),
-                    workspaceSessionId: wsSessionId,
-                    startedAt: new Date(),
-                };
-            }
+    stopIdleMonitor() {
+        if (this.idleCheckTimer) {
+            clearInterval(this.idleCheckTimer);
+            this.idleCheckTimer = null;
         }
-        return undefined;
-    }
-    destroy() {
-        this.stopIdleMonitor();
-        this.kill();
     }
 }
 //# sourceMappingURL=claude-launcher.js.map