@proletariat/cli 0.3.36 → 0.3.41

package/dist/lib/database/index.js

@@ -424,29 +424,56 @@ export function addAgentsToDatabase(workspacePath, agentNames, themeId, mountMod
     db.close();
 }
 /**
- * Add an ephemeral agent to the database
+ * Add an ephemeral agent to the database.
+ * Throws on name collision — use tryAddEphemeralAgentToDatabase for
+ * concurrency-safe insertion with conflict detection.
  */
 export function addEphemeralAgentToDatabase(workspacePath, agentName, baseName, themeId, mountMode = 'worktree') {
+    const result = tryAddEphemeralAgentToDatabase(workspacePath, agentName, baseName, themeId, mountMode);
+    if (!result) {
+        throw new Error(`Agent name "${agentName}" already exists (UNIQUE constraint failed: agents.name)`);
+    }
+    return result;
+}
+/**
+ * Try to add an ephemeral agent to the database.
+ * Returns the Agent on success, or null if the name already exists
+ * (SQLITE_CONSTRAINT_PRIMARYKEY). This is concurrency-safe: parallel
+ * processes that generate the same name will not crash — the loser
+ * simply gets null and can retry with a different name.
+ */
+export function tryAddEphemeralAgentToDatabase(workspacePath, agentName, baseName, themeId, mountMode = 'worktree') {
     const db = openWorkspaceDatabase(workspacePath);
-    const now = new Date().toISOString();
-    const worktreePath = `agents/temp/${agentName}`;
-    db.prepare(`
-    INSERT INTO agents (name, type, status, base_name, theme_id, worktree_path, mount_mode, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(agentName, 'ephemeral', 'active', baseName, themeId || null, worktreePath, mountMode, now);
-    const agent = db.prepare('SELECT * FROM agents WHERE name = ?').get(agentName);
-    db.close();
-    return {
-        name: agent.name,
-        type: agent.type,
-        status: agent.status,
-        base_name: agent.base_name,
-        theme_id: agent.theme_id,
-        worktree_path: agent.worktree_path,
-        mount_mode: (agent.mount_mode || 'clone'),
-        created_at: agent.created_at,
-        cleaned_at: agent.cleaned_at,
-    };
+    try {
+        const now = new Date().toISOString();
+        const worktreePath = `agents/temp/${agentName}`;
+        db.prepare(`
+      INSERT INTO agents (name, type, status, base_name, theme_id, worktree_path, mount_mode, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(agentName, 'ephemeral', 'active', baseName, themeId || null, worktreePath, mountMode, now);
+        const agent = db.prepare('SELECT * FROM agents WHERE name = ?').get(agentName);
+        return {
+            name: agent.name,
+            type: agent.type,
+            status: agent.status,
+            base_name: agent.base_name,
+            theme_id: agent.theme_id,
+            worktree_path: agent.worktree_path,
+            mount_mode: (agent.mount_mode || 'clone'),
+            created_at: agent.created_at,
+            cleaned_at: agent.cleaned_at,
+        };
+    }
+    catch (err) {
+        const sqliteErr = err;
+        if (sqliteErr.code === 'SQLITE_CONSTRAINT_PRIMARYKEY' || sqliteErr.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+            return null;
+        }
+        throw err;
+    }
+    finally {
+        db.close();
+    }
 }
 /**
  * Get all ephemeral agent names from the database
@@ -669,6 +696,34 @@ export function getAgentWorktrees(workspacePath, agentName) {
     db.close();
     return worktrees;
 }
+/**
+ * Find agent worktrees matching a branch pattern (case-insensitive LIKE).
+ */
+export function findWorktreesByBranch(workspacePath, branchPattern) {
+    const db = openWorkspaceDatabase(workspacePath);
+    const worktrees = db.prepare('SELECT * FROM agent_worktrees WHERE LOWER(branch) LIKE ?').all(branchPattern);
+    db.close();
+    return worktrees;
+}
+/**
+ * Get agent worktrees for a specific repository.
+ */
+export function getWorktreesForRepo(workspacePath, repoName) {
+    const db = openWorkspaceDatabase(workspacePath);
+    const worktrees = db.prepare('SELECT agent_name, is_clean, commits_ahead, branch FROM agent_worktrees WHERE repo_name = ?').all(repoName);
+    db.close();
+    return worktrees;
+}
+/**
+ * Upsert a workspace setting (key-value pair).
+ */
+export function upsertWorkspaceSetting(db, key, value) {
+    db.prepare(`
+    INSERT INTO workspace_settings (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
 /**
  * Remove agents from database
  */
@@ -685,6 +740,69 @@ export function removeAgentsFromDatabase(workspacePath, agentNames) {
     db.close();
 }
 // =============================================================================
+// PMO Bootstrapping Operations
+// =============================================================================
+/**
+ * Check if PMO tables exist and get basic stats.
+ * Used by pmo init to detect existing PMO before storage layer is available.
+ */
+export function checkPMOExists(dbPath) {
+    const db = new Database(dbPath);
+    try {
+        const result = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='pmo_projects'").get();
+        if (result === undefined) {
+            return { exists: false, projectCount: 0, ticketCount: 0 };
+        }
+        const projectCountResult = db.prepare('SELECT COUNT(*) as count FROM pmo_projects').get();
+        const ticketCountResult = db.prepare('SELECT COUNT(*) as count FROM pmo_tickets').get();
+        return {
+            exists: true,
+            projectCount: projectCountResult.count,
+            ticketCount: ticketCountResult.count,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Get a PMO setting from the pmo_settings table.
+ * Used for bootstrapping queries before storage layer is available.
+ */
+export function getPMOSetting(dbPath, key) {
+    const db = new Database(dbPath);
+    try {
+        const result = db.prepare('SELECT value FROM pmo_settings WHERE key = ?').get(key);
+        return result?.value ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Drop PMO tables from the database.
+ * Used during PMO reinitialization.
+ */
+export function dropPMOTables(dbPath, tables) {
+    const db = new Database(dbPath);
+    try {
+        for (const table of tables) {
+            try {
+                db.prepare(`DROP TABLE IF EXISTS ${table}`).run();
+            }
+            catch {
+                // Ignore errors - table might not exist
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+// =============================================================================
 // Theme CRUD Operations
 // =============================================================================
 /**

package/dist/lib/execution/runners.d.ts

@@ -74,6 +74,40 @@ export declare function getDockerCredentialInfo(): {
     expiresAt: Date;
     subscriptionType?: string;
 } | null;
+/**
+ * Preflight result indicating whether the executor is ready to run.
+ */
+export interface PreflightResult {
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Check if an executor binary is available on the host.
+ * Returns a PreflightResult with ok=true if the binary is found,
+ * or ok=false with a descriptive error and remediation hint.
+ */
+export declare function checkExecutorOnHost(executor: ExecutorType): PreflightResult;
+/**
+ * Check if an executor binary is available inside a Docker container.
+ * Returns a PreflightResult with ok=true if the binary is found,
+ * or ok=false with a descriptive error and remediation hint.
+ */
+export declare function checkExecutorInContainer(executor: ExecutorType, containerId: string): PreflightResult;
+/**
+ * Run preflight checks for a given execution environment and executor.
+ * Validates that the executor binary is available before spawning.
+ *
+ * Checks performed per environment:
+ * - host: Verify binary on PATH
+ * - devcontainer: Verify binary inside container (if container running)
+ * - docker: Verify binary on host (used in docker run command)
+ * - vm: Verify binary on host (will be checked on remote separately)
+ */
+export declare function runExecutorPreflight(executor: ExecutorType, environment: ExecutionEnvironment, containerId?: string): PreflightResult;
+export declare function getExecutorCommand(executor: ExecutorType, prompt: string, skipPermissions?: boolean): {
+    cmd: string;
+    args: string[];
+};
 export interface RunnerResult {
     success: boolean;
     pid?: string;

package/dist/lib/execution/runners.js

@@ -188,10 +188,125 @@ export function getDockerCredentialInfo() {
         return null;
     }
 }
+/**
+ * Get the binary name for an executor type.
+ */
+function getExecutorBinary(executor) {
+    switch (executor) {
+        case 'claude-code':
+            return 'claude';
+        case 'codex':
+            return 'codex';
+        case 'aider':
+            return 'aider';
+        case 'custom':
+            return 'echo'; // placeholder
+        default:
+            return 'claude';
+    }
+}
+/**
+ * Get install/setup hints for a missing executor binary.
+ */
+function getExecutorRemediationHint(executor) {
+    switch (executor) {
+        case 'claude-code':
+            return 'Install Claude Code: npm install -g @anthropic-ai/claude-code\n' +
+                '  Then authenticate: claude login';
+        case 'codex':
+            return 'Install Codex: npm install -g @openai/codex\n' +
+                '  Then authenticate: set OPENAI_API_KEY or run codex --login';
+        case 'aider':
+            return 'Install aider: pip install aider-chat\n' +
+                '  Then authenticate: set OPENAI_API_KEY or ANTHROPIC_API_KEY';
+        case 'custom':
+            return 'Configure a custom executor command in your execution settings.';
+        default:
+            return 'Install the required executor and ensure it is on your PATH.';
+    }
+}
+/**
+ * Check if an executor binary is available on the host.
+ * Returns a PreflightResult with ok=true if the binary is found,
+ * or ok=false with a descriptive error and remediation hint.
+ */
+export function checkExecutorOnHost(executor) {
+    const binary = getExecutorBinary(executor);
+    try {
+        execSync(`${binary} --version`, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10000,
+        });
+        return { ok: true };
+    }
+    catch {
+        return {
+            ok: false,
+            error: `Executor "${executor}" not found: "${binary}" is not installed or not on PATH.\n\n` +
+                `Remediation:\n  ${getExecutorRemediationHint(executor)}`,
+        };
+    }
+}
+/**
+ * Check if an executor binary is available inside a Docker container.
+ * Returns a PreflightResult with ok=true if the binary is found,
+ * or ok=false with a descriptive error and remediation hint.
+ */
+export function checkExecutorInContainer(executor, containerId) {
+    const binary = getExecutorBinary(executor);
+    try {
+        execSync(`docker exec ${containerId} which ${binary}`, {
+            stdio: 'pipe',
+            timeout: 10000,
+        });
+        return { ok: true };
+    }
+    catch {
+        return {
+            ok: false,
+            error: `Executor "${executor}" not found in container ${containerId}: "${binary}" is not installed.\n\n` +
+                `Remediation:\n  Ensure "${binary}" is installed in the devcontainer image.\n  ` +
+                getExecutorRemediationHint(executor),
+        };
+    }
+}
+/**
+ * Run preflight checks for a given execution environment and executor.
+ * Validates that the executor binary is available before spawning.
+ *
+ * Checks performed per environment:
+ * - host: Verify binary on PATH
+ * - devcontainer: Verify binary inside container (if container running)
+ * - docker: Verify binary on host (used in docker run command)
+ * - vm: Verify binary on host (will be checked on remote separately)
+ */
+export function runExecutorPreflight(executor, environment, containerId) {
+    switch (environment) {
+        case 'host':
+            return checkExecutorOnHost(executor);
+        case 'devcontainer':
+            // For devcontainer, check inside the container if it's already running
+            if (containerId) {
+                return checkExecutorInContainer(executor, containerId);
+            }
+            // Container not yet running - will be checked after container start
+            return { ok: true };
+        case 'docker':
+            // Docker runner builds the command on host, executor runs inside container
+            // Can't check until container is created, so skip for now
+            return { ok: true };
+        case 'vm':
+            // VM executor runs remotely - can't check from host
+            // Could add SSH-based check in the future
+            return { ok: true };
+        default:
+            return { ok: true };
+    }
+}
 // =============================================================================
 // Executor Commands
 // =============================================================================
-function getExecutorCommand(executor, prompt, skipPermissions = true) {
+export function getExecutorCommand(executor, prompt, skipPermissions = true) {
     switch (executor) {
         case 'claude-code':
             if (skipPermissions) {
@@ -1157,6 +1272,14 @@ export async function runDevcontainer(context, executor, config, displayMode = '
                 error: 'Failed to start Docker container. Check Docker logs for details.',
             };
         }
+        // Executor preflight check (TKT-1082): verify executor binary is available inside container
+        const preflight = checkExecutorInContainer(executor, containerId);
+        if (!preflight.ok) {
+            return {
+                success: false,
+                error: preflight.error,
+            };
+        }
         // Write prompt to file in worktree (accessible by container)
         const { hostPath: promptHostPath, containerPath: promptFile } = writePromptFile(context);
         // Inject fresh GitHub token into container (containers may be reused with stale/empty tokens)
@@ -1774,6 +1897,8 @@ exec $SHELL
 export async function runDocker(context, executor, config) {
     const prompt = buildPrompt(context);
     const containerName = `work-${context.ticketId}-${Date.now()}`;
+    // Get the correct executor command (claude, codex, aider, etc.)
+    const { cmd, args } = getExecutorCommand(executor, prompt, !config.sandboxed);
     try {
         // Check if docker is available
         execSync('which docker', { stdio: 'pipe' });
@@ -1798,10 +1923,10 @@ export async function runDocker(context, executor, config) {
         if (config.docker.cpus) {
             dockerCmd += ` --cpus ${config.docker.cpus}`;
         }
-        // Escape prompt for shell
-        const escapedPrompt = prompt.replace(/'/g, "'\\''");
+        // Build executor command with properly escaped args
+        const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
         dockerCmd += ` ${config.docker.image}`;
-        dockerCmd += ` claude --print '${escapedPrompt}'`;
+        dockerCmd += ` ${cmd} ${escapedArgs}`;
         const containerId = execSync(dockerCmd, { encoding: 'utf-8' }).trim();
         return {
             success: true,
@@ -1830,6 +1955,8 @@ export async function runVm(context, executor, config, host) {
     const user = config.vm.user;
     const keyPath = config.vm.keyPath;
     const remoteWorkspace = `/workspace/${context.agentName}`;
+    // Get the correct executor command (claude, codex, aider, etc.)
+    const { cmd, args } = getExecutorCommand(executor, prompt, !config.sandboxed);
     try {
         // Build SSH options
         let sshOpts = '';
@@ -1851,9 +1978,9 @@ export async function runVm(context, executor, config, host) {
             const gitPullCmd = `cd ${remoteWorkspace} && git fetch && git checkout ${context.branch}`;
             execSync(`ssh ${sshOpts} ${user}@${targetHost} "${gitPullCmd}"`, { stdio: 'pipe' });
         }
-        // Execute on remote
-        const escapedPrompt = prompt.replace(/'/g, "'\\''");
-        const remoteCmd = `cd ${remoteWorkspace} && claude --print '${escapedPrompt}'`;
+        // Execute on remote using the correct executor
+        const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        const remoteCmd = `cd ${remoteWorkspace} && ${cmd} ${escapedArgs}`;
         const sshCmd = `ssh ${sshOpts} ${user}@${targetHost} "nohup ${remoteCmd} > /tmp/work-${context.ticketId}.log 2>&1 &"`;
         execSync(sshCmd, { stdio: 'pipe' });
         return {

package/dist/lib/execution/session-utils.d.ts

@@ -60,6 +60,11 @@ export declare function flattenContainerSessions(containerTmuxSessions: Map<stri
     sessionName: string;
     containerId: string;
 }>;
+/**
+ * Find container sessions using prefix matching.
+ * Handles short vs full container ID mismatches between DB records and docker output.
+ */
+export declare function findContainerSessionsByPrefix(containerTmuxSessions: Map<string, string[]>, containerId: string): string[];
 /**
  * Try to find a matching tmux session for an execution with NULL sessionId.
  * First tries exact matches with known action names, then falls back to

package/dist/lib/execution/session-utils.js

@@ -127,10 +127,37 @@ export function getHostTmuxSessionNames() {
 export function getContainerTmuxSessionMap() {
     const sessionMap = new Map();
     try {
-        const containersOutput = execSync('docker ps --filter "label=devcontainer.local_folder" --format "{{.ID}}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-        if (!containersOutput)
+        const containerIds = new Set();
+        // Primary: devcontainer-labeled containers (historical behavior).
+        try {
+            const labeledOutput = execSync('docker ps --filter "label=devcontainer.local_folder" --format "{{.ID}}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (labeledOutput) {
+                for (const id of labeledOutput.split('\n')) {
+                    if (id.trim())
+                        containerIds.add(id.trim());
+                }
+            }
+        }
+        catch {
+            // Ignore and continue with broad fallback discovery.
+        }
+        // Fallback: include all running containers so prlt-managed devcontainers
+        // without the devcontainer.local_folder label are still discoverable.
+        try {
+            const allOutput = execSync('docker ps --format "{{.ID}}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (allOutput) {
+                for (const id of allOutput.split('\n')) {
+                    if (id.trim())
+                        containerIds.add(id.trim());
+                }
+            }
+        }
+        catch {
+            // Docker not available.
+        }
+        if (containerIds.size === 0)
             return sessionMap;
-        for (const containerId of containersOutput.split('\n')) {
+        for (const containerId of containerIds) {
             try {
                 const tmuxOutput = execSync(`docker exec ${containerId} tmux list-sessions -F "#{session_name}" 2>/dev/null`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
                 if (tmuxOutput) {
@@ -159,6 +186,21 @@ export function flattenContainerSessions(containerTmuxSessions) {
     });
     return result;
 }
+/**
+ * Find container sessions using prefix matching.
+ * Handles short vs full container ID mismatches between DB records and docker output.
+ */
+export function findContainerSessionsByPrefix(containerTmuxSessions, containerId) {
+    const exact = containerTmuxSessions.get(containerId);
+    if (exact)
+        return exact;
+    for (const [key, sessions] of containerTmuxSessions) {
+        if (key.startsWith(containerId) || containerId.startsWith(key)) {
+            return sessions;
+        }
+    }
+    return [];
+}
 /**
  * Try to find a matching tmux session for an execution with NULL sessionId.
  * First tries exact matches with known action names, then falls back to

package/dist/lib/execution/spawner.js

@@ -13,7 +13,7 @@ import { findHQRoot } from '../repos/index.js';
 import { hasGitHubRemote } from '../repos/git.js';
 import { hasDevcontainerConfig } from './devcontainer.js';
 import { loadExecutionConfig, getOrPromptCoderName } from './config.js';
-import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled } from './runners.js';
+import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, runExecutorPreflight } from './runners.js';
 import { detectRepoWorktrees, resolveWorktreePath } from './context.js';
 import { generateBranchName, DEFAULT_EXECUTION_CONFIG, } from './types.js';
 // =============================================================================
@@ -282,6 +282,19 @@ export async function spawnAgentForTicket(ticket, agentName, storage, executionS
     }
     const displayMode = options.displayMode || 'terminal';
     const sandboxed = !(options.skipPermissions ?? false);
+    // Executor preflight check (TKT-1082): verify binary is available before proceeding
+    // For host environment, check immediately. For devcontainer, check happens after container start.
+    if (environment === 'host') {
+        const preflight = runExecutorPreflight(executor, environment);
+        if (!preflight.ok) {
+            return {
+                success: false,
+                ticketId: ticket.id,
+                agentName,
+                error: preflight.error,
+            };
+        }
+    }
     // Create branch in worktree(s)
     // For devcontainer environments, run git commands inside the container
     // because the worktree .git file has container paths, not host paths
@@ -438,7 +451,7 @@ export async function spawnAgentForTicket(ticket, agentName, storage, executionS
         };
     }
     else {
-        executionStorage.updateStatus(execution.id, 'failed');
+        executionStorage.updateStatus(execution.id, 'failed', undefined, result.error);
         return {
             success: false,
             executionId: execution.id,

package/dist/lib/execution/storage.d.ts

@@ -33,7 +33,7 @@ export declare class ExecutionStorage {
     /**
      * Update execution status
      */
-    updateStatus(id: string, status: ExecutionStatus, exitCode?: number): void;
+    updateStatus(id: string, status: ExecutionStatus, exitCode?: number, errorMessage?: string): void;
     /**
      * Update execution with process info
      */

package/dist/lib/execution/storage.js

@@ -29,6 +29,7 @@ function rowToAgentWork(row) {
         startedAt: new Date(row.started_at),
         completedAt: row.completed_at ? new Date(row.completed_at) : undefined,
         exitCode: row.exit_code ?? undefined,
+        errorMessage: row.error_message || undefined,
     };
 }
 // =============================================================================
@@ -68,14 +69,28 @@ export class ExecutionStorage {
     /**
      * Update execution status
      */
-    updateStatus(id, status, exitCode) {
+    updateStatus(id, status, exitCode, errorMessage) {
         const completedAt = ['completed', 'failed', 'stopped'].includes(status) ? Date.now() : null;
-        if (exitCode !== undefined) {
+        if (exitCode !== undefined && errorMessage) {
+            this.db.prepare(`
+        UPDATE ${T.agent_work}
+        SET status = ?, completed_at = ?, exit_code = ?, error_message = ?
+        WHERE id = ?
+      `).run(status, completedAt, exitCode, errorMessage, id);
+        }
+        else if (exitCode !== undefined) {
             this.db.prepare(`
         UPDATE ${T.agent_work}
         SET status = ?, completed_at = ?, exit_code = ?
         WHERE id = ?
       `).run(status, completedAt, exitCode, id);
+        }
+        else if (errorMessage) {
+            this.db.prepare(`
+        UPDATE ${T.agent_work}
+        SET status = ?, completed_at = ?, error_message = ?
+        WHERE id = ?
+      `).run(status, completedAt, errorMessage, id);
         }
         else {
             this.db.prepare(`

package/dist/lib/execution/types.d.ts

@@ -57,6 +57,7 @@ export interface AgentWork {
     startedAt: Date;
     completedAt?: Date;
     exitCode?: number;
+    errorMessage?: string;
 }
 export interface ExecutionContext {
     ticketId: string;

package/dist/lib/mcp/tools/index.d.ts

@@ -17,4 +17,5 @@ export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
 export { registerDietTools } from './diet.js';
 export { registerLabelTools } from './label.js';
+export { registerTmuxTools } from './tmux.js';
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

package/dist/lib/mcp/tools/index.js

@@ -17,5 +17,6 @@ export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
 export { registerDietTools } from './diet.js';
 export { registerLabelTools } from './label.js';
+export { registerTmuxTools } from './tmux.js';
 // CLI passthrough tools
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

package/dist/lib/mcp/tools/tmux.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MCP Tmux Tools
+ *
+ * Provides tmux interaction tools for AI agents to drive interactive CLI sessions.
+ * Used by the explore-cli action to perform exploratory QA testing.
+ *
+ * Tools:
+ * - tmux_send_keys: Send keystrokes to a tmux session
+ * - tmux_capture_pane: Capture current terminal screen from a tmux session
+ * - tmux_start_session: Start a new tmux session with an optional command
+ * - tmux_list_sessions: List active tmux sessions
+ * - tmux_kill_session: Kill a tmux session
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerTmuxTools(server: McpServer, _ctx: McpToolContext): void;