@proletariat/cli 0.3.8 → 0.3.9

package/dist/lib/execution/storage.js

@@ -3,6 +3,7 @@
  *
  * Database operations for agent_work table.
  */
+import { execSync } from 'node:child_process';
 import { PMO_TABLES } from '../pmo/schema.js';
 const T = PMO_TABLES;
 // =============================================================================
@@ -190,6 +191,93 @@ export class ExecutionStorage {
             .get(agentName);
         return count.count === 0;
     }
+    /**
+     * Clean up stale executions where the tmux session no longer exists.
+     * This fixes the bug where agents appear "busy" after sessions terminate unexpectedly.
+     * Returns the number of stale executions cleaned up.
+     */
+    cleanupStaleExecutions() {
+        // Get all "running" or "starting" executions
+        const activeExecutions = this.listExecutions({ status: 'running' })
+            .concat(this.listExecutions({ status: 'starting' }));
+        if (activeExecutions.length === 0) {
+            return 0;
+        }
+        // Get list of actual tmux sessions on host
+        const hostTmuxSessions = this.getHostTmuxSessionNames();
+        // Get map of container -> tmux sessions
+        const containerTmuxSessions = this.getContainerTmuxSessionMap();
+        let cleanedCount = 0;
+        for (const exec of activeExecutions) {
+            if (!exec.sessionId) {
+                // Executions without sessionId might be stale from early termination
+                // Check if they're older than 5 minutes and mark as stopped
+                const ageMs = Date.now() - exec.startedAt.getTime();
+                if (ageMs > 5 * 60 * 1000) {
+                    this.updateStatus(exec.id, 'stopped');
+                    cleanedCount++;
+                }
+                continue;
+            }
+            let sessionExists = false;
+            if (exec.environment === 'devcontainer' && exec.containerId) {
+                // Check if session exists in container
+                const containerSessions = containerTmuxSessions.get(exec.containerId);
+                sessionExists = containerSessions?.includes(exec.sessionId) ?? false;
+            }
+            else {
+                // Check if session exists on host
+                sessionExists = hostTmuxSessions.includes(exec.sessionId);
+            }
+            if (!sessionExists) {
+                // Session doesn't exist, mark execution as stopped
+                this.updateStatus(exec.id, 'stopped');
+                cleanedCount++;
+            }
+        }
+        return cleanedCount;
+    }
+    /**
+     * 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;
+    }
     /**
      * Get total execution count for an agent (historical)
      * Used by least-busy agent selection strategy.

package/dist/lib/pmo/index.d.ts

@@ -1,3 +1,4 @@
+import { SQLiteStorage } from './storage-sqlite.js';
 export * from './types.js';
 export * from './utils.js';
 export { parseBoard, generateBoardMarkdown, findAddedTickets, findRemovedTickets, findModifiedTickets, } from './markdown.js';
@@ -9,26 +10,14 @@ export { findPMO } from './find-pmo.js';
 export { getPMOContext, type PMOContext, type GetPMOContextOptions } from './pmo-context.js';
 export { PMOCommand, pmoBaseFlags } from './base-command.js';
 export { PMO_TABLES, PMO_TABLE_SCHEMAS, PMO_INDEXES, PMO_SCHEMA_SQL, EXPECTED_TICKET_COLUMNS, validateTicketSchema, } from './schema.js';
+export { BUILTIN_TEMPLATES, getBuiltinTemplate, getPickerTemplates, getColumnsForTemplate, getColumnSettingsForTemplate, } from './templates-builtin.js';
 /**
- * Get available board templates
+ * Get available board templates (backward compatibility wrapper).
+ * @deprecated Use BUILTIN_TEMPLATES or getColumnsForTemplate() instead
  */
 export declare function getBoardTemplates(): {
     [key: string]: string[];
 };
-/**
- * Get column settings for work commands based on board template.
- * These settings determine which columns are used for:
- * - work start: moves ticket to column_in_progress
- * - work ready: moves ticket to column_review
- * - work complete: moves ticket to column_done
- *
- * For custom templates, we try to find matching columns by keyword.
- */
-export declare function getColumnSettingsForTemplate(template: string, columns: string[]): {
-    column_planned: string;
-    column_in_progress: string;
-    column_done: string;
-};
 export type PMOStorageType = 'sqlite' | 'git';
 export type PMOLocation = 'separate' | `repo:${string}`;
 export interface PMOSetupResult {
@@ -51,9 +40,10 @@ export declare function detectRepos(hqRoot: string): Array<{
  */
 export declare function promptForPMOLocation(hqRoot: string | null): Promise<PMOLocation>;
 /**
- * Prompt for board template
+ * Prompt for board template.
+ * Uses BUILTIN_TEMPLATES as the single source of truth.
  */
-export declare function promptForBoardTemplate(): Promise<string>;
+export declare function promptForBoardTemplate(_storage?: SQLiteStorage): Promise<string>;
 /**
  * Prompt for custom columns
  */
@@ -68,10 +58,6 @@ export declare function promptForBoardName(defaultName?: string): Promise<string
  * PMO is included by default (no prompt) per TKT-469 requirements.
  */
 export declare function promptForPMOSetup(hqRoot: string | null, hqName?: string): Promise<PMOSetupResult>;
-/**
- * Get columns for a board template
- */
-export declare function getColumnsForTemplate(template: string): string[];
 /**
  * Create board content for Obsidian Kanban
  */

package/dist/lib/pmo/index.js

@@ -18,94 +18,20 @@ export { findPMO } from './find-pmo.js';
 export { getPMOContext } from './pmo-context.js';
 export { PMOCommand, pmoBaseFlags } from './base-command.js';
 export { PMO_TABLES, PMO_TABLE_SCHEMAS, PMO_INDEXES, PMO_SCHEMA_SQL, EXPECTED_TICKET_COLUMNS, validateTicketSchema, } from './schema.js';
+// Re-export template utilities from shared definitions
+export { BUILTIN_TEMPLATES, getBuiltinTemplate, getPickerTemplates, getColumnsForTemplate, getColumnSettingsForTemplate, } from './templates-builtin.js';
+import { BUILTIN_TEMPLATES, getColumnsForTemplate, getColumnSettingsForTemplate, } from './templates-builtin.js';
 /**
- * Get available board templates
+ * Get available board templates (backward compatibility wrapper).
+ * @deprecated Use BUILTIN_TEMPLATES or getColumnsForTemplate() instead
  */
 export function getBoardTemplates() {
-    return {
-        // Linear-style: Simple workflow with Planned for scheduled work
-        kanban: ['Backlog', 'Planned', 'In Progress', 'Done'],
-        // Linear-style with Triage and Review columns
-        linear: ['Backlog', 'Triage', 'Todo', 'In Progress', 'In Review', 'Done'],
-        // Bug tracking workflow
-        'bug-smash': ['Reported', 'Confirmed', 'Fixing', 'Verifying', 'Fixed'],
-        // Founder template: 5-tool backlogs (by work type) + workflow stages
-        '5-tool-founder': [
-            'Ship', 'Grow', 'Support', 'Strategy', 'BizOps',
-            'In Progress', 'Review', 'Done'
-        ],
-        // Go-to-market workflow
-        'gtm': ['Ideation', 'Planning', 'In Development', 'Ready to Launch', 'Launched'],
-        // Legacy alias for founder
-        founder: [
-            'SHIP BL', 'GROW BL', 'SUPPORT BL', 'BIZOPS BL', 'STRATEGY BL',
-            'Planned', 'In Progress', 'Done', 'Dropped'
-        ],
-        custom: [] // Will be handled separately
-    };
-}
-/**
- * Get column settings for work commands based on board template.
- * These settings determine which columns are used for:
- * - work start: moves ticket to column_in_progress
- * - work ready: moves ticket to column_review
- * - work complete: moves ticket to column_done
- *
- * For custom templates, we try to find matching columns by keyword.
- */
-export function getColumnSettingsForTemplate(template, columns) {
-    // Template-specific mappings (Linear-style: planned -> in_progress -> done)
-    const templateMappings = {
-        kanban: {
-            column_planned: 'Planned',
-            column_in_progress: 'In Progress',
-            column_done: 'Done',
-        },
-        linear: {
-            column_planned: 'Todo',
-            column_in_progress: 'In Progress',
-            column_done: 'Done',
-        },
-        'bug-smash': {
-            column_planned: 'Confirmed',
-            column_in_progress: 'Fixing',
-            column_done: 'Fixed',
-        },
-        '5-tool-founder': {
-            column_planned: 'Ship',
-            column_in_progress: 'In Progress',
-            column_done: 'Done',
-        },
-        'gtm': {
-            column_planned: 'Planning',
-            column_in_progress: 'In Development',
-            column_done: 'Launched',
-        },
-        founder: {
-            column_planned: 'Planned',
-            column_in_progress: 'In Progress',
-            column_done: 'Done',
-        },
-    };
-    // Use template mapping if available
-    if (templateMappings[template]) {
-        return templateMappings[template];
+    const result = {};
+    for (const template of BUILTIN_TEMPLATES) {
+        result[template.id] = template.columns;
     }
-    // For custom templates, try to find matching columns by keyword
-    const findColumn = (keywords, fallback) => {
-        const lowerColumns = columns.map(c => c.toLowerCase());
-        for (const keyword of keywords) {
-            const idx = lowerColumns.findIndex(c => c.includes(keyword));
-            if (idx !== -1)
-                return columns[idx];
-        }
-        return fallback;
-    };
-    return {
-        column_planned: findColumn(['planned', 'ready', 'scheduled', 'todo'], columns[1] || 'Planned'),
-        column_in_progress: findColumn(['progress', 'active', 'doing', 'working'], columns[2] || 'In Progress'),
-        column_done: findColumn(['done', 'complete', 'finished', 'published', 'shipped'], columns[columns.length - 1] || 'Done'),
-    };
+    result['custom'] = []; // Special case for custom templates
+    return result;
 }
 /**
  * Detect repositories in an HQ
@@ -175,21 +101,23 @@ export async function promptForPMOLocation(hqRoot) {
     }
 }
 /**
- * Prompt for board template
+ * Prompt for board template.
+ * Uses BUILTIN_TEMPLATES as the single source of truth.
  */
-export async function promptForBoardTemplate() {
+export async function promptForBoardTemplate(_storage) {
+    // Use builtin templates directly - single source of truth
+    const pickerTemplates = BUILTIN_TEMPLATES.filter(t => t.showInPicker);
+    const choices = pickerTemplates.map(t => ({
+        name: `${t.name} (${t.columns.slice(0, 4).join(', ')}${t.columns.length > 4 ? '...' : ''})`,
+        value: t.id,
+    }));
+    // Add custom option
+    choices.push({ name: 'Custom (define your own columns)', value: 'custom' });
     const { template } = await inquirer.prompt([{
             type: 'list',
             name: 'template',
             message: 'Choose board template:',
-            choices: [
-                { name: 'Kanban - Backlog → Planned → In Progress → Done', value: 'kanban' },
-                { name: 'Linear - Backlog, Triage, Todo, In Progress, In Review, Done', value: 'linear' },
-                { name: 'Bug Smash - Reported → Confirmed → Fixing → Verifying → Fixed', value: 'bug-smash' },
-                { name: '5-Tool Founder - Ship, Grow, Support, Strategy, BizOps → In Progress → Review → Done', value: '5-tool-founder' },
-                { name: 'GTM - Ideation → Planning → In Development → Ready to Launch → Launched', value: 'gtm' },
-                { name: 'Custom (define your own columns)', value: 'custom' },
-            ],
+            choices,
             default: 'kanban',
         }]);
     return template;
@@ -253,13 +181,6 @@ export async function promptForPMOSetup(hqRoot, hqName) {
         columns,
     };
 }
-/**
- * Get columns for a board template
- */
-export function getColumnsForTemplate(template) {
-    const templates = getBoardTemplates();
-    return templates[template] || templates.kanban;
-}
 /**
  * Create board content for Obsidian Kanban
  */

package/dist/lib/pmo/storage/base.d.ts

@@ -13,8 +13,8 @@ export declare function initializePMOTables(db: Database.Database): void;
  */
 export declare function runMigrations(db: Database.Database): void;
 /**
- * Seed built-in workflows (shared workflow definitions).
- * Creates workflows from existing templates for reuse across projects.
+ * Seed built-in workflows from BUILTIN_TEMPLATES (single source of truth).
+ * Creates workflows from template definitions for reuse across projects.
  */
 export declare function seedBuiltinWorkflows(db: Database.Database): void;
 /**

package/dist/lib/pmo/storage/base.js

@@ -3,6 +3,7 @@
  * This module handles database setup and provides shared utilities.
  */
 import { PMO_TABLES, PMO_SCHEMA_SQL, validateTicketSchema } from '../schema.js';
+import { BUILTIN_TEMPLATES } from '../templates-builtin.js';
 const T = PMO_TABLES;
 /**
  * Initialize PMO tables in the database.
@@ -218,92 +219,10 @@ export function runMigrations(db) {
     }
 }
 /**
- * Seed built-in workflows (shared workflow definitions).
- * Creates workflows from existing templates for reuse across projects.
+ * Seed built-in workflows from BUILTIN_TEMPLATES (single source of truth).
+ * Creates workflows from template definitions for reuse across projects.
  */
 export function seedBuiltinWorkflows(db) {
-    // Define built-in workflows based on the template definitions
-    const builtinWorkflows = [
-        {
-            id: 'default',
-            name: 'Default',
-            description: 'Default workflow: Backlog → Ready → In Progress → Review → Done',
-            statuses: [
-                { name: 'Backlog', category: 'backlog', position: 0, isDefault: true },
-                { name: 'Ready', category: 'unstarted', position: 1 },
-                { name: 'In Progress', category: 'started', position: 2 },
-                { name: 'Review', category: 'started', position: 3 },
-                { name: 'Done', category: 'completed', position: 4 },
-            ],
-        },
-        {
-            id: 'kanban',
-            name: 'Kanban',
-            description: 'Simple kanban workflow: Backlog → To Do → In Progress → Done',
-            statuses: [
-                { name: 'Backlog', category: 'backlog', position: 0, isDefault: true },
-                { name: 'To Do', category: 'unstarted', position: 1 },
-                { name: 'In Progress', category: 'started', position: 2 },
-                { name: 'Done', category: 'completed', position: 3 },
-                { name: 'Canceled', category: 'canceled', position: 4 },
-            ],
-        },
-        {
-            id: 'linear',
-            name: 'Linear',
-            description: 'Linear-style workflow with backlog, triage, and review stages',
-            statuses: [
-                { name: 'Backlog', category: 'backlog', position: 0, isDefault: true },
-                { name: 'Triage', category: 'backlog', position: 1 },
-                { name: 'Todo', category: 'unstarted', position: 2 },
-                { name: 'In Progress', category: 'started', position: 3 },
-                { name: 'In Review', category: 'started', position: 4 },
-                { name: 'Done', category: 'completed', position: 5 },
-                { name: 'Canceled', category: 'canceled', position: 6 },
-            ],
-        },
-        {
-            id: 'bug-smash',
-            name: 'Bug Smash',
-            description: 'Bug tracking workflow with verification stages',
-            statuses: [
-                { name: 'Reported', category: 'backlog', position: 0, isDefault: true },
-                { name: 'Confirmed', category: 'unstarted', position: 1 },
-                { name: 'Fixing', category: 'started', position: 2 },
-                { name: 'Verifying', category: 'started', position: 3 },
-                { name: 'Fixed', category: 'completed', position: 4 },
-                { name: "Won't Fix", category: 'canceled', position: 5 },
-            ],
-        },
-        {
-            id: '5-tool-founder',
-            name: '5-Tool Founder',
-            description: 'Founder workflow: Ship, Grow, Support, Strategy, BizOps backlogs → In Progress → Review → Done',
-            statuses: [
-                { name: 'Ship', category: 'backlog', position: 0, isDefault: true },
-                { name: 'Grow', category: 'backlog', position: 1 },
-                { name: 'Support', category: 'backlog', position: 2 },
-                { name: 'Strategy', category: 'backlog', position: 3 },
-                { name: 'BizOps', category: 'backlog', position: 4 },
-                { name: 'In Progress', category: 'started', position: 5 },
-                { name: 'Review', category: 'started', position: 6 },
-                { name: 'Done', category: 'completed', position: 7 },
-            ],
-        },
-        {
-            id: 'gtm',
-            name: 'GTM',
-            description: 'Go-to-market workflow for launches and campaigns',
-            statuses: [
-                { name: 'Ideation', category: 'backlog', position: 0, isDefault: true },
-                { name: 'Planning', category: 'unstarted', position: 1 },
-                { name: 'In Development', category: 'started', position: 2 },
-                { name: 'Ready to Launch', category: 'started', position: 3 },
-                { name: 'Launched', category: 'completed', position: 4 },
-                { name: 'Retired', category: 'canceled', position: 5 },
-            ],
-        },
-    ];
     const now = new Date().toISOString();
     const insertWorkflow = db.prepare(`
     INSERT OR IGNORE INTO ${T.workflows} (id, name, description, is_builtin, created_at, updated_at)
@@ -313,11 +232,17 @@ export function seedBuiltinWorkflows(db) {
     INSERT OR IGNORE INTO ${T.workflow_statuses} (id, workflow_id, name, category, position, color, description, is_default, created_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
-    for (const workflow of builtinWorkflows) {
-        insertWorkflow.run(workflow.id, workflow.name, workflow.description, now, now);
-        for (const status of workflow.statuses) {
-            const statusId = `${workflow.id}-${status.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')}`;
-            insertStatus.run(statusId, workflow.id, status.name, status.category, status.position, status.color || null, null, status.isDefault ? 1 : 0, now);
+    // Read from BUILTIN_TEMPLATES - the single source of truth
+    for (const template of BUILTIN_TEMPLATES) {
+        insertWorkflow.run(template.id, template.name, template.description, now, now);
+        for (let i = 0; i < template.statuses.length; i++) {
+            const status = template.statuses[i];
+            const statusId = `${template.id}-${status.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')}`;
+            // First status is the default
+            const isDefault = i === 0;
+            insertStatus.run(statusId, template.id, status.name, status.category, status.position, null, // color
+            null, // description
+            isDefault ? 1 : 0, now);
         }
     }
     // Assign default workflow to any projects without a workflow

package/dist/lib/pmo/templates-builtin.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Builtin workflow templates - single source of truth.
+ *
+ * This file defines all builtin templates used by:
+ * - UI prompts (template selection menu)
+ * - Database seeding (pmo_templates table)
+ * - Board column creation
+ * - Work command column mappings
+ */
+import { StateCategory } from './types.js';
+export interface WorkflowTemplateStatus {
+    name: string;
+    category: StateCategory;
+    position: number;
+}
+export interface ColumnSettings {
+    column_planned: string;
+    column_in_progress: string;
+    column_done: string;
+}
+export interface BuiltinTemplate {
+    /** Unique identifier used in code and database */
+    id: string;
+    /** Display name shown in UI */
+    name: string;
+    /** Description of the workflow */
+    description: string;
+    /** Column names for the board UI */
+    columns: string[];
+    /** Workflow statuses for state tracking */
+    statuses: WorkflowTemplateStatus[];
+    /** Column mappings for work commands (start, ready, complete) */
+    columnSettings: ColumnSettings;
+    /** Whether to show in the init template picker (false for specialized templates) */
+    showInPicker: boolean;
+}
+/**
+ * All builtin workflow templates.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for:
+ * - Database seeding (seedBuiltinWorkflows reads from this)
+ * - UI template picker
+ * - Board column creation
+ * - Work command column mappings
+ *
+ * To add a new template:
+ * 1. Add it to this array
+ * 2. That's it - UI and DB will pick it up automatically
+ */
+export declare const BUILTIN_TEMPLATES: BuiltinTemplate[];
+/**
+ * Get a template by ID.
+ */
+export declare function getBuiltinTemplate(id: string): BuiltinTemplate | undefined;
+/**
+ * Get templates that should be shown in the init picker.
+ */
+export declare function getPickerTemplates(): BuiltinTemplate[];
+/**
+ * Get columns for a template (for backward compatibility).
+ */
+export declare function getColumnsForTemplate(templateId: string): string[];
+/**
+ * Get column settings for a template (for backward compatibility).
+ */
+export declare function getColumnSettingsForTemplate(templateId: string, columns: string[]): ColumnSettings;