@proletariat/cli 0.3.23 → 0.3.25

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

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

@@ -11,12 +11,4 @@ export default class SessionList extends PMOCommand {
         promptIfMultiple: boolean;
     };
     execute(): Promise<void>;
-    /**
-     * Get list of host tmux session names
-     */
-    private getHostTmuxSessionNames;
-    /**
-     * Get map of containerId -> tmux session names
-     */
-    private getContainerTmuxSessionMap;
 }

package/dist/commands/session/list.js

@@ -1,10 +1,10 @@
 import { Flags } from '@oclif/core';
-import { execSync } from 'node:child_process';
 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, } from '../../lib/execution/session-utils.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 export default class SessionList extends PMOCommand {
     static description = 'List active tmux sessions (host and container)';
@@ -28,6 +28,7 @@ export default class SessionList extends PMOCommand {
         // Get workspace info for execution records
         let executionStorage = null;
         let db = null;
+        let hasWorkspace = true;
         try {
             const workspaceInfo = getWorkspaceInfo();
             const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
@@ -35,47 +36,120 @@ export default class SessionList extends PMOCommand {
             executionStorage = new ExecutionStorage(db);
         }
         catch {
-            this.log('');
-            this.log(styles.muted('Not in a workspace. Run from a proletariat HQ directory.'));
-            this.log('');
-            return;
+            // Not in a workspace, but we can still discover tmux sessions
+            hasWorkspace = false;
         }
         try {
             // DB-driven approach: Start with executions, verify tmux sessions exist
-            const runningExecutions = executionStorage.listExecutions({ status: 'running' }) || [];
-            const startingExecutions = executionStorage.listExecutions({ status: 'starting' }) || [];
+            const runningExecutions = executionStorage?.listExecutions({ status: 'running' }) || [];
+            const startingExecutions = executionStorage?.listExecutions({ status: 'starting' }) || [];
             const activeExecutions = [...runningExecutions, ...startingExecutions];
             // Get list of actual tmux sessions for verification
-            const hostTmuxSessions = this.getHostTmuxSessionNames();
-            const containerTmuxSessions = this.getContainerTmuxSessionMap();
+            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();
             // Build verified session list from DB records
             const sessions = [];
             for (const exec of activeExecutions) {
-                if (!exec.sessionId)
-                    continue; // Skip executions without sessionId
                 const isContainer = exec.environment === 'devcontainer';
                 let exists = false;
                 let containerId;
-                if (isContainer && exec.containerId) {
-                    // Check if session exists in container
-                    const containerSessions = containerTmuxSessions.get(exec.containerId);
-                    exists = containerSessions?.includes(exec.sessionId) ?? false;
-                    containerId = exec.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 (truly has no session)
+                    if (!actualSessionId) {
+                        continue;
+                    }
                 }
                 else {
-                    // Check if session exists on host
-                    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);
+                    }
+                }
+                // Track matched sessions to detect orphans later
+                if (exists && actualSessionId) {
+                    if (isContainer && containerId) {
+                        matchedContainerSessions.add(`${containerId}:${actualSessionId}`);
+                    }
+                    else {
+                        matchedHostSessions.add(actualSessionId);
+                    }
                 }
                 // Only include if session exists, unless --all flag
-                if (exists || flags.all) {
+                // Note: actualSessionId is guaranteed non-null here due to continue above
+                if ((exists || flags.all) && actualSessionId) {
                     sessions.push({
-                        sessionId: exec.sessionId,
+                        sessionId: actualSessionId,
                         ticketId: exec.ticketId,
                         agentName: exec.agentName,
                         status: exists ? exec.status : 'stale',
                         environment: isContainer ? 'container' : 'host',
                         containerId,
                         exists,
+                        source: 'db',
+                    });
+                }
+            }
+            // 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({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        status: 'orphan',
+                        environment: 'host',
+                        exists: true,
+                        source: 'discovered',
+                    });
+                }
+            }
+            // Container sessions
+            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,
+                        status: 'orphan',
+                        environment: 'container',
+                        containerId,
+                        exists: true,
+                        source: 'discovered',
                     });
                 }
             }
@@ -84,23 +158,30 @@ export default class SessionList extends PMOCommand {
                 this.log(styles.header('🖥️  Active Sessions'));
                 this.log('═'.repeat(90));
                 this.log(styles.muted('  ' +
-                    padEnd('Session', 28) +
-                    padEnd('Ticket', 12) +
-                    padEnd('Agent', 14) +
-                    padEnd('Type', 15) +
+                    'Session'.padEnd(34) +
+                    'Ticket'.padEnd(12) +
+                    'Agent'.padEnd(18) +
+                    'Type'.padEnd(15) +
                     'Status'));
-                this.log('  ' + '─'.repeat(80));
+                this.log('  ' + '─'.repeat(88));
                 for (const session of sessions) {
                     const typeIcon = session.environment === 'container' ? '🐳 container' : '💻 host';
                     const statusColor = session.status === 'running' ? styles.success :
                         session.status === 'starting' ? styles.warning :
-                            session.status === 'stale' ? styles.error : styles.muted;
+                            session.status === 'stale' ? styles.error :
+                                session.status === 'orphan' ? styles.warning : styles.muted;
+                    // For orphan sessions, append source indicator
+                    const statusText = session.source === 'discovered' ? `${session.status}*` : session.status;
+                    // Truncate long session names to fit column
+                    const displaySession = session.sessionId.length > 32
+                        ? session.sessionId.substring(0, 29) + '...'
+                        : session.sessionId;
                     this.log('  ' +
-                        padEnd(session.sessionId, 28) +
-                        padEnd(session.ticketId, 12) +
-                        padEnd(session.agentName, 14) +
-                        padEnd(typeIcon, 15) +
-                        statusColor(session.status));
+                        displaySession.padEnd(34) +
+                        session.ticketId.padEnd(12) +
+                        session.agentName.padEnd(18) +
+                        typeIcon.padEnd(15) +
+                        statusColor(statusText));
                 }
                 this.log('');
                 this.log('═'.repeat(90));
@@ -118,12 +199,27 @@ export default class SessionList extends PMOCommand {
                     this.log(styles.muted('   Run `prlt work stop <work-id>` to clean up.'));
                     this.log('');
                 }
+                // Show orphan sessions note
+                const orphanSessions = sessions.filter(s => s.source === 'discovered');
+                if (orphanSessions.length > 0) {
+                    this.log(styles.muted(`\n📋 ${orphanSessions.length} session(s) discovered from tmux (marked with *).`));
+                    this.log(styles.muted('   These sessions match the prlt naming pattern but are not tracked in the database.'));
+                    this.log('');
+                }
             }
             else {
                 this.log('');
-                this.log(styles.muted('No active sessions found.'));
-                this.log('');
-                this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+                if (!hasWorkspace) {
+                    this.log(styles.muted('Not in a workspace and no prlt-pattern tmux sessions found.'));
+                    this.log('');
+                    this.log(styles.muted('Run from a proletariat HQ directory to see tracked sessions,'));
+                    this.log(styles.muted('or start work with: prlt work start <ticket-id>'));
+                }
+                else {
+                    this.log(styles.muted('No active sessions found.'));
+                    this.log('');
+                    this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+                }
                 this.log('');
             }
         }
@@ -131,51 +227,4 @@ export default class SessionList extends PMOCommand {
             db?.close();
         }
     }
-    /**
-     * 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'));
-                    }
-                }
-                catch {
-                    // Container has no tmux sessions
-                }
-            }
-        }
-        catch {
-            // Docker not available
-        }
-        return sessionMap;
-    }
-}
-// =============================================================================
-// Helper Functions
-// =============================================================================
-function padEnd(str, length) {
-    return str.padEnd(length);
 }

package/dist/commands/spec/create.d.ts

@@ -11,6 +11,7 @@ export default class SpecCreate extends PMOCommand {
         type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         problem: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/spec/create.js

@@ -2,7 +2,7 @@ import { Flags, Args } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 export default class SpecCreate extends PMOCommand {
     static description = 'Create a new spec';
@@ -10,6 +10,7 @@ export default class SpecCreate extends PMOCommand {
         '<%= config.bin %> <%= command.id %> "User Authentication"',
         '<%= config.bin %> <%= command.id %> --title "API Design" --type product',
         '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --title "Test" --dry-run --json  # Validate without creating',
     ];
     static args = {
         title: Args.string({
@@ -21,7 +22,7 @@ export default class SpecCreate extends PMOCommand {
         ...pmoBaseFlags,
         title: Flags.string({
             char: 't',
-            description: 'Spec title',
+            description: 'Spec title [required for non-interactive]',
         }),
         status: Flags.string({
             char: 's',
@@ -41,6 +42,10 @@ export default class SpecCreate extends PMOCommand {
             description: 'Interactive mode',
             default: false,
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating spec (use with --json for structured output)',
+            default: false,
+        }),
     };
     async execute() {
         const { args, flags } = await this.parse(SpecCreate);
@@ -98,7 +103,7 @@ export default class SpecCreate extends PMOCommand {
             });
             resolver.addPrompt({
                 flagName: 'problem',
-                type: 'input',
+                type: 'multiline',
                 message: 'Problem statement (optional):',
                 when: (ctx) => ctx.flags.title !== undefined,
             });
@@ -108,6 +113,42 @@ export default class SpecCreate extends PMOCommand {
         const specType = resolved.type === '' ? undefined : resolved.type;
         // Generate ID from title
         const specId = slugify(resolved.title);
+        // Check if spec already exists
+        const existing = await this.storage.getSpec(specId);
+        if (existing) {
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputDryRunErrorsAsJson([{ field: 'id', error: `Spec "${specId}" already exists` }], createMetadata('spec create', flags));
+                }
+            }
+            this.error(`Spec "${specId}" already exists.`);
+        }
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const wouldCreate = {
+                id: specId,
+                title: resolved.title,
+                status: resolved.status || 'draft',
+                ...(specType && { type: specType }),
+                ...(resolved.problem && { problem: resolved.problem }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('spec', wouldCreate, createMetadata('spec create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create spec:'));
+            this.log(styles.muted(`   ID: ${specId}`));
+            this.log(styles.muted(`   Title: ${resolved.title}`));
+            this.log(styles.muted(`   Status: ${resolved.status || 'draft'}`));
+            if (specType) {
+                this.log(styles.muted(`   Type: ${specType}`));
+            }
+            if (resolved.problem) {
+                this.log(styles.muted(`   Problem: ${resolved.problem}`));
+            }
+            this.log(styles.muted('\n(No spec was created)'));
+            return;
+        }
         // Create spec in database
         const spec = await this.storage.createSpec({
             id: specId,