@proletariat/cli 0.3.34 → 0.3.36

package/dist/commands/session/list.js

@@ -8,6 +8,24 @@ import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap,
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson } from '../../lib/prompt-json.js';
 import { visualPadEnd } from '../../lib/string-utils.js';
+/**
+ * Find container sessions using prefix matching.
+ * Handles cases where the stored containerId format differs from docker ps output
+ * (e.g., full 64-char ID vs 12-char short ID).
+ */
+function findContainerSessionsByPrefix(containerTmuxSessions, containerId) {
+    // Try exact match first
+    const exact = containerTmuxSessions.get(containerId);
+    if (exact)
+        return exact;
+    // Fall back to prefix matching (handles short vs full ID mismatches)
+    for (const [key, sessions] of containerTmuxSessions) {
+        if (key.startsWith(containerId) || containerId.startsWith(key)) {
+            return sessions;
+        }
+    }
+    return [];
+}
 export default class SessionList extends PMOCommand {
     static description = 'List active tmux sessions (host and container)';
     static examples = [
@@ -65,7 +83,7 @@ export default class SessionList extends PMOCommand {
                 // If sessionId is NULL, try to find session by naming convention
                 if (!exec.sessionId) {
                     if (isContainer && exec.containerId) {
-                        const containerSessions = containerTmuxSessions.get(exec.containerId) || [];
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
                         const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
                         if (match) {
                             actualSessionId = match;
@@ -88,8 +106,8 @@ export default class SessionList extends PMOCommand {
                 else {
                     // sessionId is set, verify it exists
                     if (isContainer && exec.containerId) {
-                        const containerSessions = containerTmuxSessions.get(exec.containerId);
-                        exists = containerSessions?.includes(exec.sessionId) ?? false;
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                        exists = containerSessions.includes(exec.sessionId);
                         containerId = exec.containerId;
                     }
                     else {
@@ -105,14 +123,15 @@ export default class SessionList extends PMOCommand {
                         matchedHostSessions.add(actualSessionId);
                     }
                 }
-                // Only include if session exists, unless --all flag
-                // Note: actualSessionId is guaranteed non-null here due to continue above
-                if ((exists || flags.all) && actualSessionId) {
+                // Always include sessions from DB that have a sessionId.
+                // When tmux verification fails (e.g., Docker/tmux not accessible from MCP context),
+                // show the session with the DB status instead of silently dropping it.
+                if (actualSessionId) {
                     sessions.push({
                         sessionId: actualSessionId,
                         ticketId: exec.ticketId,
                         agentName: exec.agentName,
-                        status: exists ? exec.status : 'stale',
+                        status: exists ? exec.status : (flags.all ? 'stale' : exec.status),
                         environment: isContainer ? 'container' : 'host',
                         containerId,
                         exists,

package/dist/commands/session/peek.d.ts

@@ -0,0 +1,38 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionPeek extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        target: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        lines: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Resolve a target identifier to matching sessions.
+     * Supports: agent name, ticket ID (TKT-XXX), execution ID (WORK-XXX), or session ID.
+     */
+    private resolveTarget;
+    /**
+     * Resolve an execution ID (WORK-XXX) to matching sessions.
+     */
+    private resolveFromExecution;
+    /**
+     * Output peek content for a session.
+     * In raw mode: outputs plain text to stdout.
+     * In JSON mode: outputs structured JSON.
+     */
+    private outputPeek;
+    /**
+     * Get verified sessions from DB that have actual tmux processes.
+     * Same discovery pattern as attach.ts and list.ts.
+     */
+    private getVerifiedSessions;
+}

package/dist/commands/session/peek.js

@@ -0,0 +1,316 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findSessionForExecution, captureTmuxPane, } from '../../lib/execution/session-utils.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+// =============================================================================
+// Command
+// =============================================================================
+export default class SessionPeek extends PMOCommand {
+    static description = 'View agent tmux pane content without attaching (non-interactive)';
+    static examples = [
+        '<%= config.bin %> session peek altman',
+        '<%= config.bin %> session peek TKT-123',
+        '<%= config.bin %> session peek WORK-ABCD1234',
+        '<%= config.bin %> session peek altman --lines 100',
+        '<%= config.bin %> session peek TKT-123 --json',
+        '<%= config.bin %> session peek altman | grep error',
+    ];
+    static args = {
+        target: Args.string({
+            description: 'Agent name, ticket ID (e.g. TKT-123), or execution ID (e.g. WORK-XXXXXXXX)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        lines: Flags.integer({
+            char: 'l',
+            description: 'Number of scrollback lines to capture',
+            default: 50,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionPeek);
+        const jsonMode = shouldOutputJson(flags);
+        // Discover all verified sessions
+        const sessions = this.getVerifiedSessions(jsonMode, flags);
+        if (sessions.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_SESSIONS', 'No active sessions found.', createMetadata('session peek', flags));
+                return;
+            }
+            this.log('');
+            this.log(styles.muted('No active sessions found.'));
+            this.log('');
+            this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+            this.log('');
+            return;
+        }
+        if (args.target) {
+            // Resolve target to matching session(s)
+            const matched = this.resolveTarget(args.target, sessions);
+            if (matched.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `No matching session found for "${args.target}".`, createMetadata('session peek', flags));
+                    return;
+                }
+                this.error(`No matching session found for "${args.target}". Run "prlt session list" to see available sessions.`);
+            }
+            // Output all matched sessions
+            if (jsonMode && matched.length > 1) {
+                // Collect all captures into a single JSON response
+                const results = matched.map(session => {
+                    const containerId = session.environment === 'container' ? session.containerId : undefined;
+                    const content = captureTmuxPane(session.sessionId, flags.lines, containerId);
+                    return {
+                        sessionId: session.sessionId,
+                        ticketId: session.ticketId,
+                        agentName: session.agentName,
+                        environment: session.environment,
+                        containerId: session.containerId,
+                        lines: flags.lines,
+                        content,
+                        captureError: content === null
+                            ? `Failed to capture pane content for session "${session.sessionId}".`
+                            : undefined,
+                    };
+                });
+                outputSuccessAsJson({ sessions: results }, createMetadata('session peek', flags));
+                return;
+            }
+            for (const session of matched) {
+                this.outputPeek(session, flags.lines, jsonMode, flags);
+            }
+        }
+        else {
+            // No target: interactive selection
+            const selected = await this.selectFromList({
+                message: 'Select a session to peek at:',
+                items: sessions,
+                getName: (s) => `${s.sessionId} (${s.ticketId}) - ${s.agentName} [${s.environment}]`,
+                getValue: (s) => s.sessionId,
+                getCommand: (s) => `prlt session peek "${s.sessionId}" --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'session peek' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            const session = sessions.find(s => s.sessionId === selected);
+            if (!session) {
+                this.error('No session selected');
+            }
+            this.outputPeek(session, flags.lines, jsonMode, flags);
+        }
+    }
+    /**
+     * Resolve a target identifier to matching sessions.
+     * Supports: agent name, ticket ID (TKT-XXX), execution ID (WORK-XXX), or session ID.
+     */
+    resolveTarget(target, sessions) {
+        // Try exact session ID match
+        const exactSession = sessions.filter(s => s.sessionId === target);
+        if (exactSession.length > 0)
+            return exactSession;
+        // Try ticket ID match (e.g. TKT-123)
+        if (/^[A-Z]+-\d+$/i.test(target)) {
+            const ticketTarget = target.toUpperCase();
+            const ticketMatches = sessions.filter(s => s.ticketId === ticketTarget);
+            if (ticketMatches.length > 0)
+                return ticketMatches;
+        }
+        // Try execution ID match (WORK-XXX) — resolve via DB to find session
+        if (target.toUpperCase().startsWith('WORK-')) {
+            const executionMatch = this.resolveFromExecution(target.toUpperCase(), sessions);
+            if (executionMatch.length > 0)
+                return executionMatch;
+        }
+        // Try agent name match
+        const agentMatches = sessions.filter(s => s.agentName === target);
+        if (agentMatches.length > 0)
+            return agentMatches;
+        // Try partial session ID match
+        const partialMatches = sessions.filter(s => s.sessionId.includes(target) ||
+            s.ticketId.includes(target.toUpperCase()) ||
+            s.agentName.includes(target));
+        return partialMatches;
+    }
+    /**
+     * Resolve an execution ID (WORK-XXX) to matching sessions.
+     */
+    resolveFromExecution(executionId, sessions) {
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            const executionStorage = new ExecutionStorage(db);
+            const execution = executionStorage.getExecution(executionId);
+            if (execution) {
+                return sessions.filter(s => s.ticketId === execution.ticketId && s.agentName === execution.agentName);
+            }
+        }
+        catch {
+            // Workspace not available
+        }
+        finally {
+            db?.close();
+        }
+        return [];
+    }
+    /**
+     * Output peek content for a session.
+     * In raw mode: outputs plain text to stdout.
+     * In JSON mode: outputs structured JSON.
+     */
+    outputPeek(session, lines, jsonMode, flags) {
+        const containerId = session.environment === 'container' ? session.containerId : undefined;
+        const content = captureTmuxPane(session.sessionId, lines, containerId);
+        if (content === null) {
+            if (jsonMode) {
+                outputErrorAsJson('CAPTURE_FAILED', `Failed to capture pane content for session "${session.sessionId}". The session may no longer exist or tmux may not be available.`, createMetadata('session peek', flags));
+                return;
+            }
+            this.error(`Failed to capture pane content for session "${session.sessionId}". ` +
+                'The session may no longer exist or tmux may not be available.');
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                sessionId: session.sessionId,
+                ticketId: session.ticketId,
+                agentName: session.agentName,
+                environment: session.environment,
+                containerId: session.containerId,
+                lines,
+                content,
+            }, createMetadata('session peek', flags));
+        }
+        else {
+            // Raw text output — pipeable and scriptable
+            process.stdout.write(content + '\n');
+        }
+    }
+    /**
+     * Get verified sessions from DB that have actual tmux processes.
+     * Same discovery pattern as attach.ts and list.ts.
+     */
+    getVerifiedSessions(jsonMode, flags) {
+        const sessions = [];
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            // Not in workspace — can still discover tmux sessions
+        }
+        try {
+            const hostTmuxSessions = getHostTmuxSessionNames();
+            const containerTmuxSessions = getContainerTmuxSessionMap();
+            const allContainerSessions = flattenContainerSessions(containerTmuxSessions);
+            const matchedHostSessions = new Set();
+            const matchedContainerSessions = new Set();
+            // Get active executions from DB
+            const activeExecutions = executionStorage ? [
+                ...(executionStorage.listExecutions({ status: 'running' }) || []),
+                ...(executionStorage.listExecutions({ status: 'starting' }) || []),
+            ] : [];
+            for (const exec of activeExecutions) {
+                const isContainer = exec.environment === 'devcontainer';
+                let exists = false;
+                let containerId;
+                let actualSessionId = exec.sessionId;
+                if (!exec.sessionId) {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = containerTmuxSessions.get(exec.containerId) || [];
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                            containerId = exec.containerId;
+                        }
+                    }
+                    else {
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, hostTmuxSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                        }
+                    }
+                    if (!actualSessionId)
+                        continue;
+                }
+                else {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = containerTmuxSessions.get(exec.containerId);
+                        exists = containerSessions?.includes(exec.sessionId) ?? false;
+                        containerId = exec.containerId;
+                    }
+                    else {
+                        exists = hostTmuxSessions.includes(exec.sessionId);
+                    }
+                }
+                if (exists && actualSessionId) {
+                    if (isContainer && containerId) {
+                        matchedContainerSessions.add(`${containerId}:${actualSessionId}`);
+                    }
+                    else {
+                        matchedHostSessions.add(actualSessionId);
+                    }
+                    sessions.push({
+                        sessionId: actualSessionId,
+                        ticketId: exec.ticketId,
+                        agentName: exec.agentName,
+                        environment: isContainer ? 'container' : 'host',
+                        containerId,
+                        source: 'db',
+                    });
+                }
+            }
+            // Discover orphan sessions matching prlt pattern
+            for (const sessionName of hostTmuxSessions) {
+                if (matchedHostSessions.has(sessionName))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'host',
+                        source: 'discovered',
+                    });
+                }
+            }
+            for (const { sessionName, containerId } of allContainerSessions) {
+                if (matchedContainerSessions.has(`${containerId}:${sessionName}`))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'container',
+                        containerId,
+                        source: 'discovered',
+                    });
+                }
+            }
+        }
+        finally {
+            db?.close();
+        }
+        return sessions;
+    }
+}

package/dist/commands/session/poke.d.ts

@@ -0,0 +1,27 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionPoke extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agent: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        message: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Resolve an agent identifier (name or ticket ID) to a running session.
+     * Looks up active executions and matches tmux sessions.
+     */
+    private resolveAgentSession;
+    /**
+     * Resolve the tmux session for a specific execution record.
+     */
+    private resolveSessionForExecution;
+}

package/dist/commands/session/poke.js

@@ -0,0 +1,219 @@
+import { Args } from '@oclif/core';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { getHostTmuxSessionNames, getContainerTmuxSessionMap, findSessionForExecution, } from '../../lib/execution/session-utils.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+// =============================================================================
+// tmux Helpers
+// =============================================================================
+/**
+ * Send a text message to a tmux session via send-keys.
+ * Sends the text first, then Enter separately with a small delay
+ * to avoid race conditions where Enter arrives before text is rendered.
+ */
+function sendMessage(sessionId, message, containerId) {
+    // Escape single quotes in the message for shell safety
+    const escapedMessage = message.replace(/'/g, "'\\''");
+    // Send the text first (without Enter), using -l (literal) flag so tmux
+    // does not interpret special characters - message is delivered verbatim
+    const sendTextCmd = `tmux send-keys -l -t "${sessionId}" '${escapedMessage}'`;
+    // Then send Enter separately (Enter is a tmux key name, not literal text)
+    const sendEnterCmd = `tmux send-keys -t "${sessionId}" Enter`;
+    if (containerId) {
+        execSync(`docker exec ${containerId} bash -c '${sendTextCmd}'`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 });
+        // Small delay before sending Enter to avoid race conditions
+        execSync('sleep 0.1', { stdio: ['pipe', 'pipe', 'pipe'] });
+        execSync(`docker exec ${containerId} bash -c '${sendEnterCmd}'`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 });
+    }
+    else {
+        execSync(sendTextCmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        });
+        // Small delay before sending Enter
+        execSync('sleep 0.1', { stdio: ['pipe', 'pipe', 'pipe'] });
+        execSync(sendEnterCmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        });
+    }
+}
+// =============================================================================
+// Command
+// =============================================================================
+export default class SessionPoke extends PMOCommand {
+    static description = 'Send a message to a running agent\'s Claude Code session';
+    static examples = [
+        '<%= config.bin %> session poke altman "Please focus on the tests first"',
+        '<%= config.bin %> session poke TKT-123 "Add error handling for edge cases"',
+    ];
+    static args = {
+        agent: Args.string({
+            description: 'Agent name or ticket ID of the running agent',
+            required: true,
+        }),
+        message: Args.string({
+            description: 'Message to send to the agent session',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionPoke);
+        const jsonMode = shouldOutputJson(flags);
+        const { agent, message } = args;
+        // Resolve the agent's active session
+        const resolved = this.resolveAgentSession(agent, jsonMode, flags);
+        if (!resolved)
+            return;
+        // Send the message
+        try {
+            sendMessage(resolved.sessionId, message, resolved.containerId);
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            // Check for specific container/session errors
+            if (errMsg.includes('no server running') || errMsg.includes('session not found') || errMsg.includes("can't find session")) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `tmux session "${resolved.sessionId}" does not exist. The agent may have exited.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`tmux session "${resolved.sessionId}" does not exist. The agent may have exited.`));
+                this.log(styles.muted('Use `prlt session list` to see running sessions.'));
+                this.log('');
+                return;
+            }
+            if (errMsg.includes('No such container') || errMsg.includes('is not running')) {
+                if (jsonMode) {
+                    outputErrorAsJson('CONTAINER_NOT_RUNNING', `Docker container for agent "${resolved.agentName}" is not running.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`Docker container for agent "${resolved.agentName}" is not running.`));
+                this.log(styles.muted('The container may have stopped. Check with `docker ps`.'));
+                this.log('');
+                return;
+            }
+            // Generic send failure
+            if (jsonMode) {
+                outputErrorAsJson('SEND_FAILED', `Failed to send message to agent "${resolved.agentName}": ${errMsg}`, createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error(`Failed to send message: ${errMsg}`));
+            this.log('');
+            return;
+        }
+        // Output result
+        if (jsonMode) {
+            outputSuccessAsJson({
+                success: true,
+                agent: resolved.agentName,
+                session: resolved.sessionId,
+                message,
+            }, createMetadata('session poke', flags));
+        }
+        this.log('');
+        this.log(styles.success(`Message sent to ${resolved.agentName} (${resolved.ticketId})`));
+        this.log('');
+    }
+    /**
+     * Resolve an agent identifier (name or ticket ID) to a running session.
+     * Looks up active executions and matches tmux sessions.
+     */
+    resolveAgentSession(identifier, jsonMode, flags) {
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_IN_WORKSPACE', 'Not in a workspace. Run from a proletariat HQ directory.', createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error('Not in a workspace. Run from a proletariat HQ directory.'));
+            this.log('');
+            return null;
+        }
+        try {
+            // Get active executions
+            const runningExecutions = executionStorage.listExecutions({ status: 'running' });
+            const startingExecutions = executionStorage.listExecutions({ status: 'starting' });
+            const activeExecutions = [...runningExecutions, ...startingExecutions];
+            // Find matching execution by exact agent name or exact ticket ID
+            const match = activeExecutions.find(exec => exec.agentName === identifier || exec.ticketId === identifier);
+            if (!match) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ACTIVE_EXECUTION', `Agent "${identifier}" has no active session. Use \`prlt session list\` to see running sessions.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`Agent "${identifier}" has no active session.`));
+                this.log(styles.muted('Use `prlt session list` to see running sessions.'));
+                this.log('');
+                return null;
+            }
+            return this.resolveSessionForExecution(match, jsonMode, flags);
+        }
+        finally {
+            db?.close();
+        }
+    }
+    /**
+     * Resolve the tmux session for a specific execution record.
+     */
+    resolveSessionForExecution(exec, jsonMode, flags) {
+        const isContainer = exec.environment === 'devcontainer';
+        let actualSessionId = exec.sessionId;
+        let containerId = isContainer ? exec.containerId : undefined;
+        // If sessionId is NULL, try to discover it from tmux
+        if (!exec.sessionId) {
+            if (isContainer && exec.containerId) {
+                const containerTmuxSessions = getContainerTmuxSessionMap();
+                const containerSessions = containerTmuxSessions.get(exec.containerId) || [];
+                const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
+                if (match) {
+                    actualSessionId = match;
+                    containerId = exec.containerId;
+                }
+            }
+            else {
+                const hostTmuxSessions = getHostTmuxSessionNames();
+                const match = findSessionForExecution(exec.ticketId, exec.agentName, hostTmuxSessions);
+                if (match) {
+                    actualSessionId = match;
+                }
+            }
+        }
+        if (!actualSessionId) {
+            if (jsonMode) {
+                outputErrorAsJson('SESSION_NOT_FOUND', `Could not find tmux session for agent "${exec.agentName}" (${exec.ticketId}). The session may not have started yet.`, createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error(`Could not find tmux session for agent "${exec.agentName}" (${exec.ticketId}).`));
+            this.log(styles.muted('The session may not have started yet.'));
+            this.log('');
+            return null;
+        }
+        return {
+            sessionId: actualSessionId,
+            ticketId: exec.ticketId,
+            agentName: exec.agentName,
+            environment: isContainer ? 'container' : 'host',
+            containerId,
+        };
+    }
+}