@proletariat/cli 0.3.24 → 0.3.26

package/dist/commands/roadmap/generate.js

@@ -1,12 +1,11 @@
 import { Args, Flags } from '@oclif/core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
 import { normalizePriority, PRIORITIES } from '../../lib/pmo/types.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapGenerate extends PMOCommand {
     static description = 'Generate roadmap markdown file';
     static examples = [
@@ -30,6 +29,10 @@ export default class RoadmapGenerate extends PMOCommand {
             char: 'o',
             description: 'Output directory (default: {pmoPath}/roadmaps)',
         }),
+        'exclude-done': Flags.boolean({
+            description: 'Exclude completed tickets from roadmap',
+            default: false,
+        }),
         json: Flags.boolean({
             char: 'm',
             aliases: ['machine'],
@@ -55,7 +58,7 @@ export default class RoadmapGenerate extends PMOCommand {
             }
             for (const roadmap of roadmaps) {
                 // eslint-disable-next-line no-await-in-loop -- Sequential generation with user feedback
-                await this.generateRoadmap(roadmap.id, outputDir);
+                await this.generateRoadmap(roadmap.id, outputDir, flags['exclude-done']);
             }
             this.log(styles.success(`\nGenerated ${roadmaps.length} roadmap(s) to ${outputDir}`));
             return;
@@ -71,28 +74,22 @@ export default class RoadmapGenerate extends PMOCommand {
                 }
                 this.error('No roadmaps found. Create one with: prlt roadmap create');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to generate:', choices), createMetadata('roadmap generate', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap generate' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap to generate:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap generate "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
-        await this.generateRoadmap(roadmapId, outputDir);
+        await this.generateRoadmap(roadmapId, outputDir, flags['exclude-done']);
     }
-    async generateRoadmap(roadmapId, outputDir) {
+    async generateRoadmap(roadmapId, outputDir, excludeDone = false) {
         const roadmap = await this.storage.getRoadmap(roadmapId);
         if (!roadmap) {
             this.error(`Roadmap not found: ${roadmapId}`);
@@ -124,13 +121,17 @@ export default class RoadmapGenerate extends PMOCommand {
             }
             lines.push(`## ${i + 1}. ${displayName}`);
             lines.push('');
+            // Filter tickets based on excludeDone flag
+            const filteredTickets = excludeDone
+                ? tickets.filter(t => t.statusCategory !== 'completed')
+                : tickets;
             // Group tickets by priority
             const ticketsByPriority = new Map();
             for (const priority of PRIORITIES) {
                 ticketsByPriority.set(priority, []);
             }
             ticketsByPriority.set('unset', []);
-            for (const ticket of tickets) {
+            for (const ticket of filteredTickets) {
                 const normalizedPriority = normalizePriority(ticket.priority) || 'unset';
                 const group = ticketsByPriority.get(normalizedPriority) || ticketsByPriority.get('unset');
                 group.push(ticket);
@@ -140,16 +141,15 @@ export default class RoadmapGenerate extends PMOCommand {
                 'started': 1,
                 'unstarted': 2,
                 'backlog': 3,
-                'completed': 4,
-                'canceled': 5,
-                'triage': 6,
+                'triage': 4,
             };
+            // Output active tickets by priority
             for (const [priority, priorityTickets] of ticketsByPriority) {
                 if (priorityTickets.length === 0)
                     continue;
                 priorityTickets.sort((a, b) => {
-                    const catA = categoryOrder[a.statusCategory || 'backlog'] || 6;
-                    const catB = categoryOrder[b.statusCategory || 'backlog'] || 6;
+                    const catA = categoryOrder[a.statusCategory || 'backlog'] || 5;
+                    const catB = categoryOrder[b.statusCategory || 'backlog'] || 5;
                     if (catA !== catB)
                         return catA - catB;
                     return a.id.localeCompare(b.id);
@@ -158,7 +158,6 @@ export default class RoadmapGenerate extends PMOCommand {
                 const priorityLabel = priority === 'unset' ? 'Unset Priority' : `${priority} - ${this.getPriorityLabel(priority)}`;
                 lines.push(`### ${priorityLabel} (${priorityTickets.length} ticket${priorityTickets.length > 1 ? 's' : ''})`);
                 lines.push('');
-                // Table header
                 lines.push('| Ticket | Title | Status | Category | Description |');
                 lines.push('| ------ | ----- | ------ | -------- | ----------- |');
                 for (const ticket of priorityTickets) {

package/dist/commands/roadmap/remove-project.js

@@ -1,8 +1,7 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapRemoveProject extends PMOCommand {
     static description = 'Remove a project from a roadmap';
     static examples = [
@@ -51,23 +50,17 @@ export default class RoadmapRemoveProject extends PMOCommand {
                 }
                 this.error('No roadmaps found');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap remove-project', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap remove-project' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap remove-project "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);
@@ -90,23 +83,17 @@ export default class RoadmapRemoveProject extends PMOCommand {
         // Select project
         let projectId = args.project;
         if (!projectId) {
-            if (jsonMode) {
-                const choices = projects.map((p, i) => ({
-                    name: `${i + 1}. ${p.name}`,
-                    value: p.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to remove:', choices), createMetadata('roadmap remove-project', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const projectJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap remove-project' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select project to remove:',
                     choices: projects.map((p, i) => ({
                         name: `${i + 1}. ${p.name}`,
                         value: p.id,
+                        command: `prlt roadmap remove-project "${roadmapId}" "${p.id}" --json`,
                     })),
-                }]);
+                }], projectJsonModeConfig);
             projectId = selected;
         }
         // Verify project is in roadmap
@@ -121,23 +108,16 @@ export default class RoadmapRemoveProject extends PMOCommand {
         // Confirm removal
         if (!flags.force) {
             const message = `Remove "${project.name}" from "${roadmap.name}"?`;
-            if (jsonMode) {
-                const confirmChoices = [
-                    { name: 'No, cancel', value: 'false' },
-                    { name: 'Yes, remove', value: 'true' },
-                ];
-                outputPromptAsJson(buildPromptConfig('list', 'confirmed', message, confirmChoices), createMetadata('roadmap remove-project', flags));
-                return;
-            }
-            const { confirm } = await inquirer.prompt([{
+            const confirmJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap remove-project' } : null;
+            const { confirm } = await this.prompt([{
                     type: 'list',
                     name: 'confirm',
                     message,
                     choices: [
-                        { name: 'No, cancel', value: false },
-                        { name: 'Yes, remove', value: true },
+                        { name: 'No, cancel', value: false, command: '' },
+                        { name: 'Yes, remove', value: true, command: `prlt roadmap remove-project "${roadmapId}" "${projectId}" --force --json` },
                     ],
-                }]);
+                }], confirmJsonModeConfig);
             if (!confirm) {
                 this.log(styles.muted('Cancelled.'));
                 return;

package/dist/commands/roadmap/reorder.js

@@ -1,8 +1,7 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapReorder extends PMOCommand {
     static description = 'Reorder projects in a roadmap';
     static examples = [
@@ -49,23 +48,17 @@ export default class RoadmapReorder extends PMOCommand {
                 }
                 this.error('No roadmaps found');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap reorder', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap reorder' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap reorder "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);
@@ -107,46 +100,46 @@ export default class RoadmapReorder extends PMOCommand {
         }
         this.log('');
         // Prompt to select project to move
-        if (jsonMode) {
-            const choices = projects.map((p, i) => ({
-                name: `${i + 1}. ${p.name}`,
-                value: p.id,
-            }));
-            outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to move:', choices), createMetadata('roadmap reorder', flags));
-            return;
-        }
-        const { projectToMove } = await inquirer.prompt([{
+        const projectJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap reorder' } : null;
+        const { projectToMove } = await this.prompt([{
                 type: 'list',
                 name: 'projectToMove',
                 message: 'Select project to move:',
                 choices: projects.map((p, i) => ({
                     name: `${i + 1}. ${p.name}`,
                     value: p.id,
+                    command: `prlt roadmap reorder "${roadmapId}" --project "${p.id}" --json`,
                 })),
-            }]);
+            }], projectJsonModeConfig);
         const project = projects.find(p => p.id === projectToMove);
         const currentPosition = projects.findIndex(p => p.id === projectToMove);
         // Generate position choices
         const positionChoices = projects.map((p, i) => {
             if (i === currentPosition) {
-                return { name: `${i + 1}. ${p.name} (current position)`, value: i, disabled: true };
+                return { name: `${i + 1}. ${p.name} (current position)`, value: i, disabled: true, command: '' };
             }
             const label = i < currentPosition ? `Move before ${i + 1}. ${p.name}` : `Move after ${i}. ${projects[i - 1]?.name || ''}`;
-            return { name: `Position ${i + 1}: ${label}`, value: i };
+            return {
+                name: `Position ${i + 1}: ${label}`,
+                value: i,
+                command: `prlt roadmap reorder "${roadmapId}" --project "${projectToMove}" --position ${i} --json`,
+            };
         }).filter(c => !c.disabled);
         // Add "move to end" option if not already at the end
         if (currentPosition !== projects.length - 1) {
             positionChoices.push({
                 name: `Position ${projects.length}: Move to end`,
                 value: projects.length - 1,
+                command: `prlt roadmap reorder "${roadmapId}" --project "${projectToMove}" --position ${projects.length - 1} --json`,
             });
         }
-        const { newPosition } = await inquirer.prompt([{
+        const positionJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap reorder' } : null;
+        const { newPosition } = await this.prompt([{
                 type: 'list',
                 name: 'newPosition',
                 message: `Move "${project.name}" to which position?`,
                 choices: positionChoices,
-            }]);
+            }], positionJsonModeConfig);
         await this.storage.reorderRoadmapProject(roadmapId, projectToMove, newPosition);
         // Show new order
         projects = await this.storage.listRoadmapProjects(roadmapId);

package/dist/commands/roadmap/update.js

@@ -1,8 +1,7 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapUpdate extends PMOCommand {
     static description = 'Update a roadmap';
     static examples = [
@@ -53,23 +52,17 @@ export default class RoadmapUpdate extends PMOCommand {
                 }
                 this.error('No roadmaps found. Create one with: prlt roadmap create');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to update:', choices), createMetadata('roadmap update', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap update' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap to update:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap update "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);
@@ -83,25 +76,33 @@ export default class RoadmapUpdate extends PMOCommand {
         // If no flags provided, prompt for updates
         const hasUpdateFlags = flags.name !== undefined || flags.description !== undefined || flags.default !== undefined;
         if (!hasUpdateFlags) {
-            const fields = [
-                { type: 'input', name: 'name', message: 'New name (leave blank to keep current):', default: roadmap.name },
-                { type: 'input', name: 'description', message: 'New description (leave blank to keep current):', default: roadmap.description || '' },
-                {
+            const formJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap update' } : null;
+            // Prompt for name - in JSON mode, outputs prompt and exits; agent re-runs with --name flag
+            const { name } = await this.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'New name (leave blank to keep current):',
+                    default: roadmap.name,
+                }], formJsonModeConfig);
+            // Prompt for description
+            const { description } = await this.prompt([{
+                    type: 'input',
+                    name: 'description',
+                    message: 'New description (leave blank to keep current):',
+                    default: roadmap.description || '',
+                }], formJsonModeConfig);
+            // Prompt for isDefault
+            const { isDefault } = await this.prompt([{
                     type: 'list',
                     name: 'isDefault',
                     message: 'Set as default roadmap?',
                     choices: [
-                        { name: 'No change', value: 'no-change' },
-                        { name: 'Yes', value: 'yes' },
-                        { name: 'No', value: 'no' },
+                        { name: 'No change', value: 'no-change', command: '' },
+                        { name: 'Yes', value: 'yes', command: `prlt roadmap update "${roadmapId}" --default --json` },
+                        { name: 'No', value: 'no', command: `prlt roadmap update "${roadmapId}" --no-default --json` },
                     ],
-                },
-            ];
-            if (jsonMode) {
-                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('roadmap update', flags));
-                return;
-            }
-            const answers = await inquirer.prompt(fields);
+                }], formJsonModeConfig);
+            const answers = { name, description, isDefault };
             const changes = {};
             if (answers.name && answers.name !== roadmap.name) {
                 changes.name = answers.name;

package/dist/commands/roadmap/view.js

@@ -1,8 +1,7 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapView extends PMOCommand {
     static description = 'View roadmap details and its projects';
     static examples = [
@@ -40,23 +39,17 @@ export default class RoadmapView extends PMOCommand {
                 }
                 this.error('No roadmaps found. Create one with: prlt roadmap create');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to view:', choices), createMetadata('roadmap view', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap view' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap to view:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap view "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);

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

@@ -19,16 +19,9 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Get verified sessions from DB that have actual tmux processes
      * DB-driven approach: Start with executions, verify tmux sessions exist
+     * Also discovers orphan sessions matching prlt naming pattern but not in DB
      */
     private getVerifiedSessions;
-    /**
-     * Get list of host tmux session names
-     */
-    private getHostTmuxSessionNames;
-    /**
-     * Get map of containerId -> tmux session names
-     */
-    private getContainerTmuxSessionMap;
     /**
      * Attach to session in current terminal
      */

package/dist/commands/session/attach.js

@@ -7,6 +7,7 @@ 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, } from '../../lib/execution/session-utils.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class SessionAttach extends PMOCommand {
@@ -122,6 +123,7 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Get verified sessions from DB that have actual tmux processes
      * DB-driven approach: Start with executions, verify tmux sessions exist
+     * Also discovers orphan sessions matching prlt naming pattern but not in DB
      */
     getVerifiedSessions() {
         const sessions = [];
@@ -134,87 +136,119 @@ export default class SessionAttach extends PMOCommand {
             executionStorage = new ExecutionStorage(db);
         }
         catch {
-            return sessions; // Not in workspace
+            // Not in workspace, but we can still discover tmux sessions
         }
         try {
-            // Get active executions from DB
-            const activeExecutions = [
+            // Get actual tmux sessions for verification
+            const hostTmuxSessions = getHostTmuxSessionNames();
+            const containerTmuxSessions = getContainerTmuxSessionMap();
+            // Flatten all container sessions for orphan detection
+            const allContainerSessions = flattenContainerSessions(containerTmuxSessions);
+            // Track which tmux sessions we've matched to DB records
+            const matchedHostSessions = new Set();
+            const matchedContainerSessions = new Set();
+            // Get active executions from DB (if available)
+            const activeExecutions = executionStorage ? [
                 ...(executionStorage.listExecutions({ status: 'running' }) || []),
                 ...(executionStorage.listExecutions({ status: 'starting' }) || []),
-            ];
-            // Get actual tmux sessions for verification
-            const hostTmuxSessions = this.getHostTmuxSessionNames();
-            const containerTmuxSessions = this.getContainerTmuxSessionMap();
+            ] : [];
             for (const exec of activeExecutions) {
-                if (!exec.sessionId)
-                    continue;
                 const isContainer = exec.environment === 'devcontainer';
                 let exists = false;
-                if (isContainer && exec.containerId) {
-                    const containerSessions = containerTmuxSessions.get(exec.containerId);
-                    exists = containerSessions?.includes(exec.sessionId) ?? false;
+                let containerId;
+                let actualSessionId = exec.sessionId;
+                // 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 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 still no match, skip this execution
+                    if (!actualSessionId) {
+                        continue;
+                    }
                 }
                 else {
-                    exists = hostTmuxSessions.includes(exec.sessionId);
+                    // sessionId is set, verify it exists
+                    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);
+                    }
                 }
-                // Only include sessions that actually exist
-                if (exists) {
+                // Track matched sessions
+                if (exists && actualSessionId) {
+                    if (isContainer && containerId) {
+                        matchedContainerSessions.add(`${containerId}:${actualSessionId}`);
+                    }
+                    else {
+                        matchedHostSessions.add(actualSessionId);
+                    }
                     sessions.push({
-                        name: exec.sessionId,
-                        sessionId: exec.sessionId,
+                        name: actualSessionId,
+                        sessionId: actualSessionId,
                         type: isContainer ? 'container' : 'host',
-                        containerId: exec.containerId,
+                        containerId,
                         ticketId: exec.ticketId,
                         agentName: exec.agentName,
+                        source: 'db',
                     });
                 }
             }
-        }
-        finally {
-            db?.close();
-        }
-        return sessions;
-    }
-    /**
-     * Get list of host tmux session names
-     */
-    getHostTmuxSessionNames() {
-        try {
-            execSync('which tmux', { stdio: 'pipe' });
-            const output = execSync('tmux list-sessions -F "#{session_name}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-            if (!output)
-                return [];
-            return output.split('\n');
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get map of containerId -> tmux session names
-     */
-    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)
-                return sessionMap;
-            for (const containerId of containersOutput.split('\n')) {
-                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) {
-                        sessionMap.set(containerId, tmuxOutput.split('\n'));
-                    }
+            // Discover orphan sessions: tmux sessions matching prlt pattern but not in DB
+            // Host sessions
+            for (const sessionName of hostTmuxSessions) {
+                if (matchedHostSessions.has(sessionName))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        name: sessionName,
+                        sessionId: sessionName,
+                        type: 'host',
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        source: 'discovered',
+                    });
                 }
-                catch {
-                    // Container has no tmux sessions
+            }
+            // Container sessions
+            for (const { sessionName, containerId } of allContainerSessions) {
+                if (matchedContainerSessions.has(`${containerId}:${sessionName}`))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        name: sessionName,
+                        sessionId: sessionName,
+                        type: 'container',
+                        containerId,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        source: 'discovered',
+                    });
                 }
             }
         }
-        catch {
-            // Docker not available
+        finally {
+            db?.close();
         }
-        return sessionMap;
+        return sessions;
     }
     /**
      * Attach to session in current terminal