@proletariat/cli 0.3.8 → 0.3.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chris McDermut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commands/branch/where.d.ts

@@ -0,0 +1,21 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class BranchWhere extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        search: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private getGitWorktrees;
+    private findMatchingWorktrees;
+    private findDatabaseWorktrees;
+    private getWorkspacePath;
+    private mergeResults;
+}

package/dist/commands/branch/where.js

@@ -0,0 +1,213 @@
+import { Args, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { isGitRepo, isTicketId } from '../../lib/branch/index.js';
+import { openWorkspaceDatabase } from '../../lib/database/index.js';
+export default class BranchWhere extends PMOCommand {
+    static description = 'Find which directory a branch is checked out in';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-468',
+        '<%= config.bin %> <%= command.id %> feat/chris/add-auth',
+        '<%= config.bin %> <%= command.id %> TKT-468 --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output in JSON format',
+            default: false,
+        }),
+    };
+    static args = {
+        search: Args.string({
+            description: 'Branch name or ticket ID to search for',
+            required: true,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(BranchWhere);
+        const search = args.search;
+        // Check if in git repo
+        if (!isGitRepo()) {
+            this.error('Not in a git repository.');
+        }
+        // Get all worktrees from git
+        const worktrees = this.getGitWorktrees();
+        // Search for matching branches
+        const matches = this.findMatchingWorktrees(worktrees, search);
+        // Also check the database for agent worktrees
+        const dbMatches = this.findDatabaseWorktrees(search);
+        // Combine results, preferring git worktree info
+        const allMatches = this.mergeResults(matches, dbMatches);
+        if (allMatches.length === 0) {
+            if (flags.json) {
+                this.log(JSON.stringify({ found: false, search, matches: [] }, null, 2));
+            }
+            else {
+                this.log(styles.muted(`\nNo worktree found for "${search}"\n`));
+            }
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                found: true,
+                search,
+                matches: allMatches.map(m => ({
+                    path: m.path,
+                    branch: m.branch,
+                    commit: m.commit,
+                })),
+            }, null, 2));
+        }
+        else {
+            this.log('');
+            if (allMatches.length === 1) {
+                const match = allMatches[0];
+                this.log(styles.header(`Branch: ${match.branch}`));
+                this.log(`Path: ${styles.success(match.path)}`);
+                if (match.commit) {
+                    this.log(`Commit: ${styles.muted(match.commit)}`);
+                }
+            }
+            else {
+                this.log(styles.header(`Found ${allMatches.length} matching worktrees:`));
+                this.log('');
+                for (const match of allMatches) {
+                    this.log(`  ${styles.success(match.branch)}`);
+                    this.log(`    ${match.path}`);
+                    if (match.commit) {
+                        this.log(`    ${styles.muted(`commit: ${match.commit}`)}`);
+                    }
+                    this.log('');
+                }
+            }
+            this.log('');
+        }
+    }
+    getGitWorktrees() {
+        try {
+            const output = execSync('git worktree list --porcelain', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const worktrees = [];
+            let current = {};
+            for (const line of output.split('\n')) {
+                if (line.startsWith('worktree ')) {
+                    if (current.path) {
+                        worktrees.push(current);
+                    }
+                    current = { path: line.substring(9) };
+                }
+                else if (line.startsWith('HEAD ')) {
+                    current.commit = line.substring(5);
+                }
+                else if (line.startsWith('branch refs/heads/')) {
+                    current.branch = line.substring(18);
+                }
+                else if (line === 'bare') {
+                    current.bare = true;
+                }
+                else if (line === 'detached') {
+                    current.detached = true;
+                }
+            }
+            // Don't forget the last entry
+            if (current.path) {
+                worktrees.push(current);
+            }
+            return worktrees.filter(w => w.branch && !w.bare);
+        }
+        catch {
+            return [];
+        }
+    }
+    findMatchingWorktrees(worktrees, search) {
+        const searchLower = search.toLowerCase();
+        const isTicket = isTicketId(search);
+        return worktrees.filter(w => {
+            if (!w.branch)
+                return false;
+            const branchLower = w.branch.toLowerCase();
+            // Exact match
+            if (branchLower === searchLower)
+                return true;
+            // If searching by ticket ID, match branches that start with it
+            if (isTicket && branchLower.startsWith(searchLower + '/')) {
+                return true;
+            }
+            // Partial match: branch contains the search term
+            if (branchLower.includes(searchLower))
+                return true;
+            return false;
+        });
+    }
+    findDatabaseWorktrees(search) {
+        try {
+            const workspacePath = this.getWorkspacePath();
+            if (!workspacePath)
+                return [];
+            const db = openWorkspaceDatabase(workspacePath);
+            const searchLower = search.toLowerCase();
+            const isTicket = isTicketId(search);
+            // Query for matching branches
+            let query;
+            let params;
+            if (isTicket) {
+                // Match branches starting with ticket ID
+                query = 'SELECT * FROM agent_worktrees WHERE LOWER(branch) LIKE ?';
+                params = [`${searchLower}/%`];
+            }
+            else {
+                // Match branches containing the search term
+                query = 'SELECT * FROM agent_worktrees WHERE LOWER(branch) LIKE ?';
+                params = [`%${searchLower}%`];
+            }
+            const rows = db.prepare(query).all(...params);
+            db.close();
+            return rows.map(row => ({
+                path: path.join(workspacePath, row.worktree_path),
+                branch: row.branch,
+                commit: row.last_commit_hash || '',
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    getWorkspacePath() {
+        // Try to find workspace by looking for .proletariat directory
+        let current = process.cwd();
+        const root = path.parse(current).root;
+        while (current !== root) {
+            try {
+                const dbPath = path.join(current, '.proletariat', 'workspace.db');
+                const fs = require('node:fs');
+                if (fs.existsSync(dbPath)) {
+                    return current;
+                }
+            }
+            catch {
+                // Continue searching
+            }
+            current = path.dirname(current);
+        }
+        return null;
+    }
+    mergeResults(gitWorktrees, dbWorktrees) {
+        // Use git worktrees as primary source, add any db-only entries
+        const seen = new Set(gitWorktrees.map(w => w.branch));
+        const merged = [...gitWorktrees];
+        for (const dbw of dbWorktrees) {
+            if (!seen.has(dbw.branch)) {
+                merged.push(dbw);
+                seen.add(dbw.branch);
+            }
+        }
+        return merged;
+    }
+}

package/dist/commands/pmo/init.js

@@ -5,16 +5,18 @@ import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import Database from 'better-sqlite3';
-import { SQLiteStorage, getColumnsForTemplate, createPMO, promptForPMOLocation, promptForBoardTemplate, promptForBoardName, promptForCustomColumns, determinePMOPath, } from '../../lib/pmo/index.js';
+import { SQLiteStorage, getColumnsForTemplate, createPMO, promptForPMOLocation, promptForBoardTemplate, promptForBoardName, promptForCustomColumns, determinePMOPath, getPickerTemplates, } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { isGHInstalled, isGHAuthenticated, getGHUsername, isGHTokenInEnv } from '../../lib/pr/index.js';
 import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+// Build template options dynamically from shared definitions (picker templates + custom)
+const PICKER_TEMPLATE_IDS = [...getPickerTemplates().map(t => t.id), 'custom'];
 export default class PMOInit extends Command {
     static description = 'Initialize PMO (Project Management Org) in current directory or HQ';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --location repo:proletariat --template founder',
-        '<%= config.bin %> <%= command.id %> --location separate --template scrum',
+        '<%= config.bin %> <%= command.id %> --location repo:proletariat --template 5-tool',
+        '<%= config.bin %> <%= command.id %> --location separate --template linear',
     ];
     static flags = {
         location: Flags.string({
@@ -24,7 +26,7 @@ export default class PMOInit extends Command {
         template: Flags.string({
             char: 't',
             description: 'Board template',
-            options: ['kanban', 'scrum', 'founder', 'custom'],
+            options: PICKER_TEMPLATE_IDS,
         }),
         name: Flags.string({
             char: 'n',
@@ -93,12 +95,28 @@ export default class PMOInit extends Command {
             location = await promptForPMOLocation(hqRoot);
         }
         // Get board template using shared prompt (or from flag)
+        // If DB exists, query it for templates (source of truth)
         let template;
         if (flags.template) {
             template = flags.template;
         }
         else {
-            template = await promptForBoardTemplate();
+            let storage;
+            if (hqRoot) {
+                const dbPath = path.join(hqRoot, '.proletariat', 'workspace.db');
+                if (fs.existsSync(dbPath)) {
+                    try {
+                        storage = new SQLiteStorage(dbPath);
+                    }
+                    catch {
+                        // Ignore - will fall back to builtin templates
+                    }
+                }
+            }
+            template = await promptForBoardTemplate(storage);
+            if (storage) {
+                await storage.close();
+            }
         }
         // Get columns for template
         let columns = getColumnsForTemplate(template);

package/dist/commands/project/create.js

@@ -2,10 +2,12 @@ import { Flags, Args } from '@oclif/core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import inquirer from 'inquirer';
-import { createBoardContent, createSpecFolders, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { createBoardContent, createSpecFolders, PMOCommand, pmoBaseFlags, BUILTIN_TEMPLATES } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
 import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+// Build template options dynamically from shared definitions
+const TEMPLATE_IDS = BUILTIN_TEMPLATES.map(t => t.id);
 export default class ProjectCreate extends PMOCommand {
     static description = 'Create a new project in the PMO';
     static examples = [
@@ -35,7 +37,7 @@ export default class ProjectCreate extends PMOCommand {
         template: Flags.string({
             char: 't',
             description: 'Workflow template',
-            options: ['kanban', 'linear', 'bug-smash', '5-tool-founder', 'gtm'],
+            options: TEMPLATE_IDS,
             default: 'kanban',
         }),
         interactive: Flags.boolean({
@@ -58,14 +60,11 @@ export default class ProjectCreate extends PMOCommand {
         // Get project data first (before storage so prompts work)
         let projectData;
         if (flags.interactive || (!args.name && !flags.name)) {
-            // Build choices once - single source of truth
-            const templateChoices = [
-                { name: 'Kanban - Backlog → To Do → 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' },
-            ];
+            // Build choices dynamically from shared template definitions
+            const templateChoices = BUILTIN_TEMPLATES.map(t => ({
+                name: `${t.name} - ${t.statuses.map(s => s.name).join(' → ')}`,
+                value: t.id,
+            }));
             // Define fields once - single source of truth for both JSON and interactive modes
             const fields = [
                 { type: 'input', name: 'name', message: 'Project name:', default: flags.name },

package/dist/commands/whoami.d.ts

@@ -4,6 +4,7 @@ export default class Whoami extends Command {
     static examples: string[];
     run(): Promise<void>;
     private detectAgentName;
+    private findWorkspaceRoot;
     private detectRepoName;
     private getCurrentBranch;
 }

package/dist/commands/whoami.js

@@ -1,7 +1,9 @@
 import { Command } from '@oclif/core';
 import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { execSync } from 'node:child_process';
 import { colors } from '../lib/colors.js';
+import { getAgentByPath } from '../lib/database/index.js';
 export default class Whoami extends Command {
     static description = 'Show current agent/environment context';
     static examples = [
@@ -43,6 +45,11 @@ export default class Whoami extends Command {
         if (pmoPath) {
             this.log(`  PMO path:    ${colors.textMuted(pmoPath)}`);
         }
+        // Show host path if available (set in devcontainer for agent identity)
+        const hostPath = process.env.PRLT_HOST_PATH;
+        if (hostPath) {
+            this.log(`  Host path:   ${colors.textMuted(hostPath)}`);
+        }
         this.log('');
     }
     detectAgentName() {
@@ -50,18 +57,30 @@ export default class Whoami extends Command {
         if (process.env.PRLT_AGENT_NAME) {
             return process.env.PRLT_AGENT_NAME;
         }
-        // Try to detect from directory structure
-        // Pattern: /workspace/proletariat-{agentName} or agents/staff/{agentName}
         const cwd = process.cwd();
+        // Try database lookup (most reliable on host)
+        const workspacePath = this.findWorkspaceRoot(cwd);
+        if (workspacePath) {
+            try {
+                const agent = getAgentByPath(workspacePath, cwd);
+                if (agent) {
+                    return agent.name;
+                }
+            }
+            catch {
+                // DB lookup failed, fall back to other methods
+            }
+        }
+        // Fallback: detect from directory structure
         // Devcontainer pattern: /workspace/proletariat-{agent}
         const workspaceMatch = cwd.match(/\/workspace\/[^/]+-(\w+)/);
         if (workspaceMatch) {
             return workspaceMatch[1];
         }
-        // Host pattern: agents/staff/{agent}
-        const staffMatch = cwd.match(/agents\/staff\/(\w+)/);
-        if (staffMatch) {
-            return staffMatch[1];
+        // Host pattern: agents/staff/{agent} or agents/temp/{agent}
+        const agentDirMatch = cwd.match(/agents\/(?:staff|temp)\/([\w-]+)/);
+        if (agentDirMatch) {
+            return agentDirMatch[1];
         }
         // Try git branch pattern: agent-{name}
         try {
@@ -76,6 +95,17 @@ export default class Whoami extends Command {
         }
         return null;
     }
+    findWorkspaceRoot(startDir) {
+        let currentDir = startDir;
+        while (currentDir !== '/') {
+            const dbPath = path.join(currentDir, '.proletariat', 'workspace.db');
+            if (fs.existsSync(dbPath)) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return null;
+    }
     detectRepoName() {
         // Try to get repo name from directory or git remote
         try {

package/dist/commands/work/start.js

@@ -318,6 +318,12 @@ export default class WorkStart extends PMOCommand {
                 // Get staff agents that exist on disk (warns about missing directories)
                 const activeStaffAgents = getActiveStaffAgents(workspaceInfo, (msg) => this.log(msg));
                 if (activeStaffAgents.length > 0) {
+                    // Clean up stale executions before checking availability (TKT-604)
+                    // This fixes agents appearing as "busy" when their sessions have terminated
+                    const cleanedUp = executionStorage.cleanupStaleExecutions();
+                    if (cleanedUp > 0) {
+                        this.log(styles.muted(`   Cleaned up ${cleanedUp} stale execution(s)`));
+                    }
                     // Get list of busy agents (already running something)
                     const busyAgentNames = new Set();
                     for (const agent of activeStaffAgents) {
@@ -1156,6 +1162,11 @@ export default class WorkStart extends PMOCommand {
         this.log('');
         // Get staff agents that exist on disk (warns about missing directories)
         const activeStaffAgents = getActiveStaffAgents(workspaceInfo, (msg) => this.log(msg));
+        // Clean up stale executions before checking availability (TKT-604)
+        const cleanedUp = executionStorage.cleanupStaleExecutions();
+        if (cleanedUp > 0) {
+            this.log(styles.muted(`   Cleaned up ${cleanedUp} stale execution(s)`));
+        }
         const busyAgentNames = new Set();
         for (const agent of activeStaffAgents) {
             const runningExecutions = executionStorage.getAgentRunningExecutions(agent.name);

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

@@ -109,6 +109,12 @@ export declare function removeEphemeralAgent(workspacePath: string, agentName: s
  * Get all agents in workspace
  */
 export declare function getWorkspaceAgents(workspacePath: string, includeCleanedUp?: boolean): Agent[];
+/**
+ * Get an agent by directory path.
+ * Looks up agent where the given absolute path is inside the agent's worktree.
+ * Returns null if no matching agent found.
+ */
+export declare function getAgentByPath(workspacePath: string, absolutePath: string): Agent | null;
 /**
  * Mark an agent as cleaned up (keeps the record for history)
  */

package/dist/lib/database/index.js

@@ -379,6 +379,44 @@ export function getWorkspaceAgents(workspacePath, includeCleanedUp = false) {
         cleaned_at: row.cleaned_at,
     }));
 }
+/**
+ * Get an agent by directory path.
+ * Looks up agent where the given absolute path is inside the agent's worktree.
+ * Returns null if no matching agent found.
+ */
+export function getAgentByPath(workspacePath, absolutePath) {
+    // Normalize paths
+    const normalizedWorkspace = path.resolve(workspacePath);
+    const normalizedPath = path.resolve(absolutePath);
+    // Path must be inside workspace
+    if (!normalizedPath.startsWith(normalizedWorkspace)) {
+        return null;
+    }
+    // Get relative path from workspace root
+    const relativePath = path.relative(normalizedWorkspace, normalizedPath);
+    const db = openWorkspaceDatabase(workspacePath);
+    const agents = db.prepare("SELECT * FROM agents WHERE status = 'active' OR status IS NULL").all();
+    db.close();
+    // Find agent whose worktree_path matches or contains the relative path
+    for (const row of agents) {
+        if (row.worktree_path) {
+            // Check if relativePath starts with or equals the agent's worktree_path
+            if (relativePath === row.worktree_path || relativePath.startsWith(row.worktree_path + '/')) {
+                return {
+                    name: row.name,
+                    type: (row.type || 'persistent'),
+                    status: (row.status || 'active'),
+                    base_name: row.base_name,
+                    theme_id: row.theme_id,
+                    worktree_path: row.worktree_path,
+                    created_at: row.created_at,
+                    cleaned_at: row.cleaned_at,
+                };
+            }
+        }
+    }
+    return null;
+}
 /**
  * Mark an agent as cleaned up (keeps the record for history)
  */

package/dist/lib/execution/devcontainer.js

@@ -65,6 +65,9 @@ export function generateDevcontainerJson(options, config) {
             GH_TOKEN: '${localEnv:GH_TOKEN}',
             GITHUB_TOKEN: '${localEnv:GITHUB_TOKEN}',
             PRLT_HQ_PATH: '/hq',
+            // Agent identity - allows agent to know its name and host path
+            PRLT_AGENT_NAME: options.agentName,
+            PRLT_HOST_PATH: options.agentDir,
             // /hq/.proletariat/bin contains prlt wrapper with ESM loader for native modules
             PATH: '/hq/.proletariat/bin:/home/node/.npm-global/bin:/usr/local/bin:/usr/bin:/bin',
         },

package/dist/lib/execution/runners.js

@@ -639,8 +639,9 @@ export async function runDevcontainer(context, executor, config, displayMode = '
             result.containerId = containerId;
         }
         // Set sessionId when using tmux inside the container
+        // Use buildSessionName to match the actual tmux session name format: {ticketId}-{action}-{agentName}
         if (result.success && sessionManager === 'tmux') {
-            const sessionId = context.ticketId.replace(/[^a-zA-Z0-9-]/g, '-');
+            const sessionId = buildSessionName(context);
             result.sessionId = sessionId;
             // For terminal display mode, verify the tmux session was actually created
             // (terminal spawns asynchronously, so we need to wait and check)
@@ -649,7 +650,7 @@ export async function runDevcontainer(context, executor, config, displayMode = '
                 await new Promise(resolve => setTimeout(resolve, 3000));
                 // Check if tmux session exists inside the container
                 try {
-                    const checkResult = execSync(`docker exec ${containerId} tmux has-session -t ${sessionId} 2>&1`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+                    const checkResult = execSync(`docker exec ${containerId} tmux has-session -t "${sessionId}" 2>&1`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
                     // Session exists - success
                 }
                 catch (err) {

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

@@ -57,7 +57,9 @@ interface AgentWithExecutionCount {
  */
 export declare function getAgentsWithCounts(workspaceInfo: WorkspaceInfo, executionStorage: ExecutionStorage): AgentWithExecutionCount[];
 /**
- * Get agents that are not currently running any executions.
+ * Get staff agents that are not currently running any executions.
+ * Only considers persistent (staff) agents with status='active'.
+ * Cleans up stale executions before checking availability (TKT-604).
  */
 export declare function getAvailableAgents(workspaceInfo: WorkspaceInfo, executionStorage: ExecutionStorage): string[];
 /**

package/dist/lib/execution/spawner.js

@@ -93,11 +93,18 @@ export function getAgentsWithCounts(workspaceInfo, executionStorage) {
     });
 }
 /**
- * Get agents that are not currently running any executions.
+ * Get staff agents that are not currently running any executions.
+ * Only considers persistent (staff) agents with status='active'.
+ * Cleans up stale executions before checking availability (TKT-604).
  */
 export function getAvailableAgents(workspaceInfo, executionStorage) {
+    // Clean up stale executions first (TKT-604)
+    executionStorage.cleanupStaleExecutions();
+    // Filter for active staff agents only (not ephemeral agents)
     return workspaceInfo.agents
-        .filter(agent => executionStorage.isAgentAvailable(agent.name))
+        .filter(agent => agent.type === 'persistent' &&
+        agent.status === 'active' &&
+        executionStorage.isAgentAvailable(agent.name))
         .map(agent => agent.name);
 }
 /**

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

@@ -64,6 +64,20 @@ export declare class ExecutionStorage {
      * Check if agent is available (not running anything)
      */
     isAgentAvailable(agentName: string): boolean;
+    /**
+     * 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(): number;
+    /**
+     * Get list of host tmux session names
+     */
+    private getHostTmuxSessionNames;
+    /**
+     * Get map of containerId -> tmux session names
+     */
+    private getContainerTmuxSessionMap;
     /**
      * Get total execution count for an agent (historical)
      * Used by least-busy agent selection strategy.