@proletariat/cli 0.3.9 → 0.3.11

package/dist/commands/work/watch.js

@@ -7,7 +7,7 @@ import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
 import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
-import { spawnForColumn, getAvailableAgents, isDockerRunning, } from '../../lib/execution/spawner.js';
+import { spawnForColumn, getAvailableAgents, isDockerRunning, isDevcontainerCliInstalled, } from '../../lib/execution/spawner.js';
 import { promptExecutionSettings } from '../../lib/execution/config.js';
 import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
 export default class WorkWatch extends PMOCommand {
@@ -169,11 +169,17 @@ export default class WorkWatch extends PMOCommand {
                 this.warn('Docker is not running. Agents will run on host instead of devcontainer.\n' +
                     'Start Docker Desktop for sandboxed execution.');
             }
+            // Devcontainer CLI check
+            const devcontainerCliInstalled = isDevcontainerCliInstalled();
+            if (hasDevcontainer && dockerRunning && !devcontainerCliInstalled) {
+                this.warn('devcontainer CLI is not installed. Agents will run on host instead of devcontainer.\n' +
+                    'Install with: npm install -g @devcontainers/cli');
+            }
             // Prompt for environment and display mode if not provided
             this.environment = 'host';
             this.displayMode = 'terminal';
             if (!flags.mode) {
-                if (hasDevcontainer && dockerRunning) {
+                if (hasDevcontainer && dockerRunning && devcontainerCliInstalled) {
                     // Prompt for environment choice
                     const { selectedEnvironment } = await inquirer.prompt([
                         {
@@ -275,8 +281,10 @@ export default class WorkWatch extends PMOCommand {
             this.log(styles.muted('Press Ctrl+C to stop watching'));
             this.log('');
             while (this.isRunning) {
+                // eslint-disable-next-line no-await-in-loop -- Continuous polling loop
                 await this.pollForNewTickets(flags, executionStorage, workspaceInfo, db);
                 // Wait for interval
+                // eslint-disable-next-line no-await-in-loop -- Poll interval delay
                 await new Promise(resolve => setTimeout(resolve, flags.interval * 1000));
             }
             db.close();

package/dist/commands/workflow/create.js

@@ -72,10 +72,9 @@ export default class WorkflowCreate extends PMOCommand {
             name: name,
             description: flags.description,
         });
-        // If statuses were provided, add them
+        // If statuses were provided, add them sequentially for consistent ordering
         if (flags.statuses) {
-            const statusNames = flags.statuses.split(',').map(s => s.trim()).filter(s => s);
-            const defaultCategories = ['backlog', 'unstarted', 'started', 'started', 'completed'];
+            const statusNames = flags.statuses.split(',').map(s => s.trim()).filter(Boolean);
             for (let i = 0; i < statusNames.length; i++) {
                 const statusName = statusNames[i];
                 // Assign categories based on position: first = backlog, second = unstarted, middle = started, last = completed
@@ -92,6 +91,7 @@ export default class WorkflowCreate extends PMOCommand {
                 else {
                     category = 'started';
                 }
+                // eslint-disable-next-line no-await-in-loop
                 await this.storage.createStatus(workflow.id, {
                     name: statusName,
                     category: category,

package/dist/commands/workflow/switch.js

@@ -93,7 +93,7 @@ export default class WorkflowSwitch extends PMOCommand {
         const defaultStatus = newStatuses.find(s => s.isDefault) || newStatuses[0];
         // Update project workflow_id
         await this.storage.updateProject(projectId, { workflowId: workflowId });
-        // Migrate tickets to new statuses
+        // Migrate tickets to new statuses - sequential for data integrity
         let migratedCount = 0;
         for (const ticket of tickets) {
             // Get old status category
@@ -102,6 +102,7 @@ export default class WorkflowSwitch extends PMOCommand {
             const newStatus = categoryToStatus[oldCategory] ||
                 (defaultStatus ? { id: defaultStatus.id, name: defaultStatus.name } : null);
             if (newStatus) {
+                // eslint-disable-next-line no-await-in-loop
                 await this.storage.moveTicket(projectId, ticket.id, newStatus.name);
                 migratedCount++;
             }

package/dist/commands/workspace/remove.js

@@ -25,14 +25,6 @@ export default class WorkspaceRemove extends Command {
         const { args, flags } = await this.parse(WorkspaceRemove);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // Helper to handle errors in JSON mode
-        const handleError = (code, message) => {
-            if (jsonMode) {
-                outputErrorAsJson(code, message, createMetadata('workspace remove', flags));
-                this.exit(1);
-            }
-            this.error(message);
-        };
         const input = args.nameOrPath;
         // Resolve workspace path
         const workspacePath = await this.resolveWorkspacePath(input, jsonMode, flags);

package/dist/commands/workspace/use.js

@@ -4,7 +4,7 @@ import inquirer from 'inquirer';
 import * as fs from 'node:fs';
 import { isValidHQ } from '../../lib/workspace.js';
 import { findWorkspacesByName, findWorkspaceByPath, setActiveWorkspace, normalizePath, getRegisteredWorkspaces, } from '../../lib/machine-config.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
 export default class WorkspaceUse extends Command {
     static description = 'Set the active workspace';
     static examples = [
@@ -27,14 +27,6 @@ export default class WorkspaceUse extends Command {
         const { args, flags } = await this.parse(WorkspaceUse);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // Helper to handle errors in JSON mode
-        const handleError = (code, message) => {
-            if (jsonMode) {
-                outputErrorAsJson(code, message, createMetadata('workspace use', flags));
-                this.exit(1);
-            }
-            this.error(message);
-        };
         const input = args.nameOrPath;
         // First, try to find by path
         const normalizedPath = normalizePath(input);

package/dist/lib/agents/commands.js

@@ -5,8 +5,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
 import inquirer from 'inquirer';
-import { getWorkspaceConfig, getWorkspaceAgents, getWorkspaceRepositories, getAgentWorktrees, addAgentsToDatabase, removeAgentsFromDatabase, addEphemeralAgentToDatabase, getEphemeralAgentNames, getActiveTheme, markAgentCleaned, syncAgentsWithDisk } from '../database/index.js';
-import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, getThemePersistentDir, getThemeEphemeralDir, } from '../themes.js';
+import { getWorkspaceConfig, getWorkspaceAgents, getWorkspaceRepositories, getAgentWorktrees, addAgentsToDatabase, removeAgentsFromDatabase, addEphemeralAgentToDatabase, getEphemeralAgentNames, getActiveTheme, markAgentCleaned, discoverAgentsOnDisk } from '../database/index.js';
+import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, getThemePersistentDir, getThemeEphemeralDir, extractBaseName, getAgentBaseName, } from '../themes.js';
 import { createDevcontainerConfig } from '../execution/devcontainer.js';
 import { getPMOContext } from '../pmo/index.js';
 /**
@@ -29,8 +29,8 @@ export function getWorkspaceInfo() {
             try {
                 const config = getWorkspaceConfig(hqPath);
                 if (config) {
-                    // Sync agents with disk - mark missing ones as cleaned
-                    syncAgentsWithDisk(hqPath);
+                    // Discover agents on disk and sync with database
+                    discoverAgentsOnDisk(hqPath);
                     const agents = getWorkspaceAgents(hqPath);
                     const repositories = getWorkspaceRepositories(hqPath);
                     const activeTheme = getActiveTheme(hqPath);
@@ -66,8 +66,8 @@ export function getWorkspaceInfo() {
             try {
                 const config = getWorkspaceConfig(currentDir);
                 if (config) {
-                    // Sync agents with disk - mark missing ones as cleaned
-                    syncAgentsWithDisk(currentDir);
+                    // Discover agents on disk and sync with database
+                    discoverAgentsOnDisk(currentDir);
                     const agents = getWorkspaceAgents(currentDir);
                     const repositories = getWorkspaceRepositories(currentDir);
                     const activeTheme = getActiveTheme(currentDir);
@@ -366,10 +366,12 @@ export async function removeAgentsFromWorkspace(workspaceInfo, agentNames) {
         // Clear ticket assignees for removed agents
         try {
             const { storage } = await getPMOContext();
+            // eslint-disable-next-line unicorn/no-useless-undefined
             const allTickets = await storage.listTickets(undefined);
             for (const ticket of allTickets) {
                 if (ticket.assignee && removed.includes(ticket.assignee)) {
                     // Pass null to clear the assignee in the database
+                    // eslint-disable-next-line no-await-in-loop -- Sequential updates for cleanup
                     await storage.updateTicket(ticket.id, { assignee: null });
                 }
             }
@@ -388,8 +390,8 @@ export async function removeAgentsFromWorkspace(workspaceInfo, agentNames) {
 export async function createEphemeralAgent(workspaceInfo, options) {
     // Get existing agent names for uniqueness check
     const existingNames = new Set([
-        ...workspaceInfo.agents.map(a => a.name.toLowerCase()),
-        ...Array.from(getEphemeralAgentNames(workspaceInfo.path))
+        ...Array.from(getEphemeralAgentNames(workspaceInfo.path)),
+        ...workspaceInfo.agents.map(a => a.name.toLowerCase())
     ]);
     const log = options?.log;
     // Get theme: use provided themeId, or fall back to workspace's active theme
@@ -400,6 +402,9 @@ export async function createEphemeralAgent(workspaceInfo, options) {
     // Use theme-specific ephemeral directory
     const ephemeralDir = themeId ? getThemeEphemeralDir(themeId) : workspaceInfo.ephemeralAgentsDir;
     const tempAgentsBasePath = path.join(workspaceInfo.path, 'agents', ephemeralDir);
+    // Extract base names currently in use by active agents
+    // This helps the generator prefer fresh base names
+    const inUseBaseNames = new Set(workspaceInfo.agents.map(agent => getAgentBaseName(agent).toLowerCase()));
     // Create a conflict checker for external resources (tmux sessions, directories)
     const checkExternalConflict = (candidateName) => {
         // Check if a tmux session with this name already exists (could be from manual creation)
@@ -421,12 +426,12 @@ export async function createEphemeralAgent(workspaceInfo, options) {
     const nameOptions = {
         themeId,
         checkExternalConflict,
-        onConflictSkipped
+        onConflictSkipped,
+        inUseBaseNames
     };
     const agentName = generateEphemeralAgentName(existingNames, nameOptions);
-    // Extract base name from the generated name (e.g., "bezos" from "bold-bezos-1")
-    const parts = agentName.split('-');
-    const baseName = parts.length >= 3 ? parts.slice(1, -1).join('-') : agentName;
+    // Extract base name from the generated name (e.g., "bezos" from "bold-bezos" or "bold-bezos-2")
+    const baseName = extractBaseName(agentName);
     // Create temp agents directory if it doesn't exist
     if (!fs.existsSync(tempAgentsBasePath)) {
         fs.mkdirSync(tempAgentsBasePath, { recursive: true });
@@ -452,7 +457,7 @@ export async function createEphemeralAgent(workspaceInfo, options) {
                         stdio: 'pipe'
                     });
                 }
-                catch (error) {
+                catch {
                     // If worktree creation fails, try to just create the directory
                     // The agent can still work without a worktree (e.g., for non-git projects)
                     if (!fs.existsSync(worktreePath)) {

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

@@ -38,7 +38,6 @@ export interface AgentTheme {
 export interface AgentThemeName {
     theme_id: string;
     name: string;
-    used: boolean;
 }
 export interface AgentWorktree {
     agent_name: string;
@@ -125,6 +124,20 @@ export declare function markAgentCleaned(workspacePath: string, agentName: strin
  * Returns list of agents that were cleaned up.
  */
 export declare function syncAgentsWithDisk(workspacePath: string): string[];
+export interface DiscoverResult {
+    discovered: {
+        name: string;
+        type: AgentType;
+        path: string;
+    }[];
+    cleaned: string[];
+}
+/**
+ * Discover agents on disk that aren't in the database and register them.
+ * Also cleans up agents in DB whose directories no longer exist.
+ * Returns both discovered and cleaned agents.
+ */
+export declare function discoverAgentsOnDisk(workspacePath: string): DiscoverResult;
 /**
  * Get all repositories in workspace
  */
@@ -162,21 +175,15 @@ export declare function deleteTheme(workspacePath: string, themeId: string): boo
 /**
  * Get names for a theme
  */
-export declare function getThemeNames(workspacePath: string, themeId: string, includeUsed?: boolean): AgentThemeName[];
+export declare function getThemeNames(workspacePath: string, themeId: string): AgentThemeName[];
 /**
- * Get available (unused) names for a theme
- * Also excludes names that match existing agents (case-insensitive)
+ * Get available names for a theme.
+ * A name is available if:
+ * 1. No staff agent exists in the database with that name (case-insensitive), OR
+ * 2. The agent exists but its worktree directory is missing (manually deleted)
  */
 export declare function getAvailableThemeNames(workspacePath: string, themeId: string): string[];
 /**
  * Add names to a theme (case-insensitive uniqueness)
  */
 export declare function addThemeNames(workspacePath: string, themeId: string, names: string[]): void;
-/**
- * Mark a theme name as used
- */
-export declare function markThemeNameUsed(workspacePath: string, themeId: string, name: string): void;
-/**
- * Mark a theme name as available
- */
-export declare function markThemeNameAvailable(workspacePath: string, themeId: string, name: string): void;

package/dist/lib/database/index.js

@@ -1,7 +1,7 @@
 import Database from 'better-sqlite3';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getThemePersistentDir } from '../themes.js';
+import { getThemePersistentDir, isEphemeralAgentName } from '../themes.js';
 import { PMO_SCHEMA_SQL } from '../pmo/schema.js';
 const CREATE_TABLES_SQL = `
 -- Core workspace metadata
@@ -39,7 +39,6 @@ CREATE TABLE IF NOT EXISTS agent_themes (
 CREATE TABLE IF NOT EXISTS agent_theme_names (
   theme_id TEXT NOT NULL,
   name TEXT NOT NULL,
-  used BOOLEAN DEFAULT FALSE,
   PRIMARY KEY (theme_id, name),
   FOREIGN KEY (theme_id) REFERENCES agent_themes(id) ON DELETE CASCADE
 );
@@ -102,6 +101,20 @@ function ensureEphemeralAgentTypes(db) {
     WHERE type != 'ephemeral'
     AND name GLOB '*-*-[0-9]*'
   `);
+    // Also detect numberless ephemeral names (e.g., bold-bezos) using isEphemeralAgentName()
+    // This catches agents that match the adjective-name pattern but don't have a number suffix
+    const potentialEphemeral = db.prepare(`
+    SELECT name FROM agents
+    WHERE type != 'ephemeral'
+    AND name LIKE '%-%'
+    AND name NOT GLOB '*-*-[0-9]*'
+  `).all();
+    const updateStmt = db.prepare("UPDATE agents SET type = 'ephemeral' WHERE name = ?");
+    for (const agent of potentialEphemeral) {
+        if (isEphemeralAgentName(agent.name)) {
+            updateStmt.run(agent.name);
+        }
+    }
 }
 /**
  * Get the database path for a workspace
@@ -125,6 +138,7 @@ export function openWorkspaceDatabase(workspacePath) {
     }
     const db = new Database(dbPath);
     db.pragma('foreign_keys = ON');
+    db.pragma('busy_timeout = 5000'); // Wait up to 5 seconds if database is locked
     // Ensure ephemeral agents are correctly typed
     ensureEphemeralAgentTypes(db);
     // Ensure theme tables exist
@@ -140,13 +154,35 @@ export function openWorkspaceDatabase(workspacePath) {
     CREATE TABLE IF NOT EXISTS agent_theme_names (
       theme_id TEXT NOT NULL,
       name TEXT NOT NULL,
-      used BOOLEAN DEFAULT FALSE,
       PRIMARY KEY (theme_id, name),
       FOREIGN KEY (theme_id) REFERENCES agent_themes(id) ON DELETE CASCADE
     );
     CREATE INDEX IF NOT EXISTS idx_theme_names_theme ON agent_theme_names(theme_id);
     CREATE INDEX IF NOT EXISTS idx_agents_theme ON agents(theme_id);
   `);
+    // Migration: drop 'used' column if it exists (no longer needed)
+    try {
+        const tableInfo = db.prepare("PRAGMA table_info(agent_theme_names)").all();
+        if (tableInfo.some(col => col.name === 'used')) {
+            // SQLite doesn't support DROP COLUMN directly, so recreate the table
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_theme_names_new (
+          theme_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          PRIMARY KEY (theme_id, name),
+          FOREIGN KEY (theme_id) REFERENCES agent_themes(id) ON DELETE CASCADE
+        );
+        INSERT OR IGNORE INTO agent_theme_names_new (theme_id, name)
+          SELECT theme_id, name FROM agent_theme_names;
+        DROP TABLE agent_theme_names;
+        ALTER TABLE agent_theme_names_new RENAME TO agent_theme_names;
+        CREATE INDEX IF NOT EXISTS idx_theme_names_theme ON agent_theme_names(theme_id);
+      `);
+        }
+    }
+    catch {
+        // Ignore migration errors - table might not exist yet
+    }
     return db;
 }
 /**
@@ -454,6 +490,93 @@ export function syncAgentsWithDisk(workspacePath) {
     }
     return cleanedAgents;
 }
+/**
+ * Discover agents on disk that aren't in the database and register them.
+ * Also cleans up agents in DB whose directories no longer exist.
+ * Returns both discovered and cleaned agents.
+ */
+export function discoverAgentsOnDisk(workspacePath) {
+    const result = { discovered: [], cleaned: [] };
+    // First, clean up missing agents
+    result.cleaned = syncAgentsWithDisk(workspacePath);
+    // Get existing ACTIVE agents from DB (case-insensitive lookup)
+    const activeAgents = getWorkspaceAgents(workspacePath, false); // Only active agents
+    const activeNames = new Set(activeAgents.map(a => a.name.toLowerCase()));
+    // Get ALL agents including cleaned (for reactivation)
+    const allAgents = getWorkspaceAgents(workspacePath, true);
+    const cleanedAgents = new Map(allAgents.filter(a => a.status === 'cleaned').map(a => [a.name.toLowerCase(), a]));
+    const db = openWorkspaceDatabase(workspacePath);
+    try {
+        // Scan staff directory
+        const staffDir = path.join(workspacePath, 'agents', 'staff');
+        if (fs.existsSync(staffDir)) {
+            const staffEntries = fs.readdirSync(staffDir, { withFileTypes: true });
+            for (const entry of staffEntries) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const nameLower = entry.name.toLowerCase();
+                    if (!activeNames.has(nameLower)) {
+                        const worktreePath = `agents/staff/${entry.name}`;
+                        const now = new Date().toISOString();
+                        // Check if this is a cleaned agent that should be reactivated
+                        const cleanedAgent = cleanedAgents.get(nameLower);
+                        if (cleanedAgent) {
+                            // Reactivate the cleaned agent
+                            db.prepare(`
+                UPDATE agents SET status = 'active', cleaned_at = NULL, worktree_path = ?
+                WHERE LOWER(name) = LOWER(?)
+              `).run(worktreePath, entry.name);
+                        }
+                        else {
+                            // Register new agent
+                            db.prepare(`
+                INSERT INTO agents (name, type, status, worktree_path, created_at)
+                VALUES (?, 'persistent', 'active', ?, ?)
+              `).run(entry.name, worktreePath, now);
+                        }
+                        result.discovered.push({ name: entry.name, type: 'persistent', path: worktreePath });
+                        activeNames.add(nameLower);
+                    }
+                }
+            }
+        }
+        // Scan temp directory
+        const tempDir = path.join(workspacePath, 'agents', 'temp');
+        if (fs.existsSync(tempDir)) {
+            const tempEntries = fs.readdirSync(tempDir, { withFileTypes: true });
+            for (const entry of tempEntries) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const nameLower = entry.name.toLowerCase();
+                    if (!activeNames.has(nameLower)) {
+                        const worktreePath = `agents/temp/${entry.name}`;
+                        const now = new Date().toISOString();
+                        // Check if this is a cleaned agent that should be reactivated
+                        const cleanedAgent = cleanedAgents.get(nameLower);
+                        if (cleanedAgent) {
+                            // Reactivate the cleaned agent
+                            db.prepare(`
+                UPDATE agents SET status = 'active', cleaned_at = NULL, worktree_path = ?
+                WHERE LOWER(name) = LOWER(?)
+              `).run(worktreePath, entry.name);
+                        }
+                        else {
+                            // Register new agent
+                            db.prepare(`
+                INSERT INTO agents (name, type, status, worktree_path, created_at)
+                VALUES (?, 'ephemeral', 'active', ?, ?)
+              `).run(entry.name, worktreePath, now);
+                        }
+                        result.discovered.push({ name: entry.name, type: 'ephemeral', path: worktreePath });
+                        activeNames.add(nameLower);
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+    return result;
+}
 /**
  * Get all repositories in workspace
  */
@@ -477,17 +600,10 @@ export function getAgentWorktrees(workspacePath, agentName) {
  */
 export function removeAgentsFromDatabase(workspacePath, agentNames) {
     const db = openWorkspaceDatabase(workspacePath);
-    const getAgent = db.prepare('SELECT theme_id, name FROM agents WHERE name = ?');
     const deleteAgent = db.prepare('DELETE FROM agents WHERE name = ?');
-    const clearUsedFlag = db.prepare('UPDATE agent_theme_names SET used = 0 WHERE theme_id = ? AND name = ?');
     // Note: agent_worktrees will be deleted automatically due to CASCADE
     const transaction = db.transaction(() => {
         for (const agentName of agentNames) {
-            // Clear used flag if agent came from a theme
-            const agent = getAgent.get(agentName);
-            if (agent?.theme_id) {
-                clearUsedFlag.run(agent.theme_id, agentName);
-            }
             deleteAgent.run(agentName);
         }
     });
@@ -551,31 +667,47 @@ export function deleteTheme(workspacePath, themeId) {
 /**
  * Get names for a theme
  */
-export function getThemeNames(workspacePath, themeId, includeUsed = true) {
+export function getThemeNames(workspacePath, themeId) {
     const db = openWorkspaceDatabase(workspacePath);
-    const query = includeUsed
-        ? 'SELECT * FROM agent_theme_names WHERE theme_id = ? ORDER BY name'
-        : 'SELECT * FROM agent_theme_names WHERE theme_id = ? AND used = 0 ORDER BY name';
-    const names = db.prepare(query).all(themeId);
+    const names = db.prepare('SELECT * FROM agent_theme_names WHERE theme_id = ? ORDER BY name').all(themeId);
     db.close();
     return names;
 }
 /**
- * Get available (unused) names for a theme
- * Also excludes names that match existing agents (case-insensitive)
+ * Get available names for a theme.
+ * A name is available if:
+ * 1. No staff agent exists in the database with that name (case-insensitive), OR
+ * 2. The agent exists but its worktree directory is missing (manually deleted)
  */
 export function getAvailableThemeNames(workspacePath, themeId) {
     const db = openWorkspaceDatabase(workspacePath);
-    // Get unused theme names
-    const names = db.prepare('SELECT name FROM agent_theme_names WHERE theme_id = ? AND used = 0 ORDER BY name').all(themeId);
-    // Get existing agent names (lowercase for comparison)
-    const existingAgents = db.prepare('SELECT LOWER(name) as name FROM agents').all();
-    const existingSet = new Set(existingAgents.map(a => a.name));
+    // Get all theme names
+    const names = db.prepare('SELECT name FROM agent_theme_names WHERE theme_id = ? ORDER BY name').all(themeId);
+    // Get existing staff agents with their worktree paths (persistent type only)
+    const existingAgents = db.prepare(`
+    SELECT LOWER(name) as name, worktree_path
+    FROM agents
+    WHERE type = 'persistent' AND (status = 'active' OR status IS NULL)
+  `).all();
     db.close();
-    // Filter out names that match existing agents
+    // Build a set of names that are truly in use (agent exists AND worktree exists)
+    const inUseNames = new Set();
+    for (const agent of existingAgents) {
+        if (agent.worktree_path) {
+            const fullPath = path.join(workspacePath, agent.worktree_path);
+            if (fs.existsSync(fullPath)) {
+                inUseNames.add(agent.name);
+            }
+        }
+        else {
+            // No worktree path means we can't verify - treat as in use to be safe
+            inUseNames.add(agent.name);
+        }
+    }
+    // Filter out names that are truly in use
     return names
         .map(n => n.name)
-        .filter(name => !existingSet.has(name.toLowerCase()));
+        .filter(name => !inUseNames.has(name.toLowerCase()));
 }
 /**
  * Add names to a theme (case-insensitive uniqueness)
@@ -585,8 +717,8 @@ export function addThemeNames(workspacePath, themeId, names) {
     // Check for existing name (case-insensitive)
     const checkExisting = db.prepare('SELECT name FROM agent_theme_names WHERE theme_id = ? AND LOWER(name) = LOWER(?)');
     const insertName = db.prepare(`
-    INSERT INTO agent_theme_names (theme_id, name, used)
-    VALUES (?, ?, 0)
+    INSERT INTO agent_theme_names (theme_id, name)
+    VALUES (?, ?)
   `);
     const transaction = db.transaction(() => {
         for (const name of names) {
@@ -601,19 +733,3 @@ export function addThemeNames(workspacePath, themeId, names) {
     transaction();
     db.close();
 }
-/**
- * Mark a theme name as used
- */
-export function markThemeNameUsed(workspacePath, themeId, name) {
-    const db = openWorkspaceDatabase(workspacePath);
-    db.prepare('UPDATE agent_theme_names SET used = 1 WHERE theme_id = ? AND name = ?').run(themeId, name);
-    db.close();
-}
-/**
- * Mark a theme name as available
- */
-export function markThemeNameAvailable(workspacePath, themeId, name) {
-    const db = openWorkspaceDatabase(workspacePath);
-    db.prepare('UPDATE agent_theme_names SET used = 0 WHERE theme_id = ? AND name = ?').run(themeId, name);
-    db.close();
-}

package/dist/lib/docker/resolve.js

@@ -4,7 +4,7 @@
  * Resolves various identifiers to Docker container IDs.
  * Accepts: execution ID (WORK-XXX), agent name, or container ID.
  */
-import { execSync } from 'child_process';
+import { execSync } from 'node:child_process';
 /**
  * Validate and sanitize a container ID to prevent shell injection.
  * Docker container IDs are 64-character hex strings (or 12-char short form).

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

@@ -8,6 +8,7 @@ import Database from 'better-sqlite3';
 import { ExecutionConfig, TerminalApp, Shell, DisplayMode, OutputMode, ExecutionEnvironment } from './types.js';
 declare const CONFIG_KEYS: {
     terminalApp: string;
+    terminalOpenInBackground: string;
     shell: string;
     defaultMode: string;
     defaultExecutor: string;
@@ -46,6 +47,11 @@ export declare function saveShell(db: Database.Database, shell: Shell): void;
  * When enabled and using iTerm, tmux -CC is used for native tab integration.
  */
 export declare function saveTmuxControlMode(db: Database.Database, enabled: boolean): void;
+/**
+ * Save terminal open in background preference.
+ * When enabled, new terminal tabs open without stealing focus from current window.
+ */
+export declare function saveTerminalOpenInBackground(db: Database.Database, enabled: boolean): void;
 /**
  * Check if terminal app preference has been set
  */

package/dist/lib/execution/config.js

@@ -7,11 +7,12 @@
 import inquirer from 'inquirer';
 import { DEFAULT_EXECUTION_CONFIG } from './types.js';
 import { isGHInstalled, isGHAuthenticated } from '../pr/index.js';
-import { execSync } from 'child_process';
+import { execSync } from 'node:child_process';
 const SETTINGS_TABLE = 'workspace_settings';
 // Config keys stored in workspace_settings table
 const CONFIG_KEYS = {
     terminalApp: 'execution.terminal.app',
+    terminalOpenInBackground: 'execution.terminal.open_in_background',
     shell: 'execution.shell',
     defaultMode: 'execution.default_mode',
     defaultExecutor: 'execution.default_executor',
@@ -56,7 +57,12 @@ export function loadExecutionConfig(db) {
     // Load terminal app
     const terminalApp = getSetting(db, CONFIG_KEYS.terminalApp);
     if (terminalApp) {
-        config.terminal = { app: terminalApp };
+        config.terminal = { ...config.terminal, app: terminalApp };
+    }
+    // Load terminal open in background setting
+    const terminalOpenInBackground = getSetting(db, CONFIG_KEYS.terminalOpenInBackground);
+    if (terminalOpenInBackground !== null) {
+        config.terminal = { ...config.terminal, openInBackground: terminalOpenInBackground === 'true' };
     }
     // Load shell
     const shell = getSetting(db, CONFIG_KEYS.shell);
@@ -152,6 +158,13 @@ export function saveShell(db, shell) {
 export function saveTmuxControlMode(db, enabled) {
     setSetting(db, CONFIG_KEYS.tmuxControlMode, enabled.toString());
 }
+/**
+ * Save terminal open in background preference.
+ * When enabled, new terminal tabs open without stealing focus from current window.
+ */
+export function saveTerminalOpenInBackground(db, enabled) {
+    setSetting(db, CONFIG_KEYS.terminalOpenInBackground, enabled.toString());
+}
 /**
  * Check if terminal app preference has been set
  */

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

@@ -12,6 +12,8 @@ export interface DevcontainerOptions {
     memory?: string;
     cpus?: number;
     timezone?: string;
+    /** prlt channel: "npm", "npm:dev", "gh", "gh:dev", "mount", or version like "npm:1.2.3" */
+    prltChannel?: string;
 }
 export interface DevcontainerJson {
     name: string;