@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/workspace/list.js

@@ -0,0 +1,153 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { findAllHQs, findHQRootWithSource, isValidHQ } from '../../lib/workspace.js';
+import { getRegisteredWorkspaces, getActiveWorkspace, } from '../../lib/machine-config.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export default class WorkspaceList extends Command {
+    static description = 'List all registered and discovered HQ workspaces';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output as JSON for machine-readable format',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceList);
+        const cwd = process.cwd();
+        // Get registered workspaces from machine config
+        const registeredWorkspaces = getRegisteredWorkspaces();
+        const activeWorkspacePath = getActiveWorkspace();
+        // Also find any workspaces in directory tree (for backward compatibility)
+        const discoveredHQs = findAllHQs(cwd);
+        // Get the current active workspace (from findHQRootWithSource)
+        const currentWorkspace = findHQRootWithSource(cwd);
+        // Build unified workspace list
+        const workspaces = [];
+        const seenPaths = new Set();
+        // Add registered workspaces first
+        for (const workspace of registeredWorkspaces) {
+            const exists = fs.existsSync(workspace.path);
+            const isActive = activeWorkspacePath === workspace.path ||
+                currentWorkspace?.path === workspace.path;
+            let hasPMO = false;
+            if (exists) {
+                const dbPath = path.join(workspace.path, '.proletariat', 'workspace.db');
+                hasPMO = fs.existsSync(dbPath);
+            }
+            workspaces.push({
+                name: workspace.name,
+                path: workspace.path,
+                isActive,
+                exists,
+                hasPMO,
+                registeredAt: workspace.registeredAt,
+                source: 'registry',
+            });
+            seenPaths.add(workspace.path);
+        }
+        // Add discovered workspaces that aren't in the registry
+        for (const hqPath of discoveredHQs) {
+            if (seenPaths.has(hqPath))
+                continue;
+            // Get workspace info
+            const configPath = path.join(hqPath, '.proletariat', 'config.json');
+            let workspaceName = path.basename(hqPath);
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                    workspaceName = config.name || workspaceName;
+                }
+                catch {
+                    // Use defaults
+                }
+            }
+            // Check if it has PMO
+            const dbPath = path.join(hqPath, '.proletariat', 'workspace.db');
+            const hasPMO = fs.existsSync(dbPath);
+            const isActive = currentWorkspace?.path === hqPath;
+            workspaces.push({
+                name: workspaceName,
+                path: hqPath,
+                isActive,
+                exists: true,
+                hasPMO,
+                source: 'discovered',
+            });
+        }
+        // JSON output
+        if (flags.json) {
+            const output = {
+                workspaces: workspaces.map((w) => ({
+                    name: w.name,
+                    path: w.path,
+                    active: w.isActive,
+                    exists: w.exists,
+                    hasPMO: w.hasPMO,
+                    registeredAt: w.registeredAt,
+                    source: w.source,
+                })),
+                activeWorkspace: activeWorkspacePath,
+                envOverride: process.env.PRLT_HQ_PATH || null,
+            };
+            this.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        // Human-readable output
+        if (workspaces.length === 0) {
+            this.log(chalk.yellow('No workspaces found.'));
+            this.log(chalk.gray('Run "prlt init" to create a new workspace.'));
+            return;
+        }
+        this.log(chalk.blue('\nRegistered workspaces:\n'));
+        for (const workspace of workspaces) {
+            const activeMarker = workspace.isActive ? chalk.green(' (active)') : '';
+            const envMarker = workspace.isActive && currentWorkspace?.source === 'env'
+                ? chalk.cyan(' [via PRLT_HQ_PATH]')
+                : '';
+            const pmoMarker = workspace.hasPMO
+                ? chalk.gray(' [has PMO]')
+                : chalk.gray(' [no PMO]');
+            const unregisteredMarker = workspace.source === 'discovered'
+                ? chalk.yellow(' [not registered]')
+                : '';
+            if (!workspace.exists) {
+                // Warning for stale registration
+                this.log(`  ${chalk.red('⚠')} ${chalk.strikethrough(chalk.white(workspace.name))}${activeMarker}`);
+                this.log(chalk.red(`    Path no longer exists: ${workspace.path}`));
+            }
+            else {
+                this.log(`  ${chalk.white(workspace.name)}${activeMarker}${envMarker}${pmoMarker}${unregisteredMarker}`);
+                this.log(chalk.gray(`    Path: ${workspace.path}`));
+            }
+            this.log('');
+        }
+        // Show warning for unregistered workspaces
+        const unregistered = workspaces.filter((w) => w.source === 'discovered');
+        if (unregistered.length > 0) {
+            this.log(chalk.yellow('Some workspaces are not registered.'));
+            this.log(chalk.gray('Run "prlt workspace add <path>" to register them.'));
+            this.log('');
+        }
+        // Show helpful hints if multiple workspaces found
+        const registeredCount = workspaces.filter((w) => w.source === 'registry').length;
+        if (registeredCount > 1) {
+            this.log(chalk.gray('To switch workspaces, run:'));
+            this.log(chalk.cyan('  prlt workspace use <name|path>'));
+            this.log('');
+        }
+        // Show PRLT_HQ_PATH if set
+        if (process.env.PRLT_HQ_PATH) {
+            this.log(chalk.blue('Current PRLT_HQ_PATH:'));
+            this.log(chalk.cyan(`  ${process.env.PRLT_HQ_PATH}`));
+            if (!isValidHQ(process.env.PRLT_HQ_PATH)) {
+                this.log(chalk.red('  (Warning: This path is not a valid HQ workspace)'));
+            }
+            this.log('');
+        }
+    }
+}

package/dist/commands/workspace/remove.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceRemove extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        nameOrPath: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private resolveWorkspacePath;
+}

package/dist/commands/workspace/remove.js

@@ -0,0 +1,98 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { findWorkspacesByName, findWorkspaceByPath, unregisterWorkspace, normalizePath, getActiveWorkspace, } from '../../lib/machine-config.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class WorkspaceRemove extends Command {
+    static description = 'Unregister a workspace from the machine config (does NOT delete files)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-workspace',
+        '<%= config.bin %> <%= command.id %> /path/to/workspace',
+    ];
+    static args = {
+        nameOrPath: Args.string({
+            description: 'Workspace name or path to unregister',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        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);
+        // Check if this is the active workspace
+        const activeWorkspace = getActiveWorkspace();
+        const wasActive = activeWorkspace === workspacePath;
+        // Unregister the workspace
+        const removed = unregisterWorkspace(workspacePath);
+        if (removed) {
+            this.log(chalk.green(`Unregistered workspace: ${workspacePath}`));
+            this.log(chalk.gray('Note: Files were NOT deleted, only removed from registry.'));
+            if (wasActive) {
+                this.log(chalk.yellow('This was the active workspace. Active workspace has been cleared.'));
+                this.log(chalk.gray('Run "prlt workspace use <name>" to set a new active workspace.'));
+            }
+        }
+        else {
+            this.error(`Failed to unregister workspace: ${workspacePath}`);
+        }
+    }
+    async resolveWorkspacePath(input, jsonMode = false, flags = {}) {
+        // First, try to find by path
+        const normalizedPath = normalizePath(input);
+        const byPath = findWorkspaceByPath(normalizedPath);
+        if (byPath) {
+            return byPath.path;
+        }
+        // Try to find by name
+        const matches = findWorkspacesByName(input);
+        if (matches.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('WORKSPACE_NOT_FOUND', `Workspace not found: ${input}`, createMetadata('workspace remove', flags));
+                this.exit(1);
+            }
+            this.error(`Workspace not found: ${input}`);
+        }
+        if (matches.length === 1) {
+            return matches[0].path;
+        }
+        // Build choices once, use for both JSON and interactive modes
+        const workspaceChoices = matches.map((w) => ({
+            name: `${w.name} - ${w.path}`,
+            value: w.path,
+        }));
+        const message = `Multiple workspaces found with name "${input}". Which workspace do you want to remove?`;
+        // In JSON mode, output workspace selection prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'workspacePath', message, workspaceChoices), createMetadata('workspace remove', flags));
+            this.exit(0);
+        }
+        // Multiple workspaces with same name - prompt user to choose
+        this.log(chalk.yellow(`Multiple workspaces found with name "${input}":`));
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selected',
+                message: 'Which workspace do you want to remove?',
+                choices: workspaceChoices,
+            },
+        ]);
+        return selected;
+    }
+}

package/dist/commands/workspace/use.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceUse extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        nameOrPath: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspace/use.js

@@ -0,0 +1,111 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+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';
+export default class WorkspaceUse extends Command {
+    static description = 'Set the active workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-workspace',
+        '<%= config.bin %> <%= command.id %> /path/to/workspace',
+    ];
+    static args = {
+        nameOrPath: Args.string({
+            description: 'Workspace name or path',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        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);
+        let workspace = findWorkspaceByPath(normalizedPath);
+        if (!workspace) {
+            // Try to find by name
+            const matches = findWorkspacesByName(input);
+            if (matches.length === 0) {
+                // Check if input is a valid path that exists but isn't registered
+                if (fs.existsSync(normalizedPath) && isValidHQ(normalizedPath)) {
+                    this.log(chalk.yellow(`Workspace at "${normalizedPath}" exists but is not registered.`));
+                    this.log(chalk.gray('Run "prlt workspace add" to register it first, or specify a registered workspace.'));
+                    this.log('');
+                    this.log(chalk.gray('Registered workspaces:'));
+                    const registered = getRegisteredWorkspaces();
+                    if (registered.length === 0) {
+                        this.log(chalk.gray('  (none)'));
+                    }
+                    else {
+                        for (const w of registered) {
+                            this.log(chalk.gray(`  - ${w.name} (${w.path})`));
+                        }
+                    }
+                    this.error('Workspace not registered');
+                }
+                this.error(`Workspace not found: ${input}`);
+            }
+            if (matches.length > 1) {
+                // Build choices once, use for both JSON and interactive modes
+                const workspaceChoices = matches.map((w) => ({
+                    name: `${w.name} - ${w.path}`,
+                    value: w.path,
+                }));
+                const message = `Multiple workspaces found with name "${input}". Which workspace do you want to use?`;
+                // In JSON mode, output workspace selection prompt
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'workspacePath', message, workspaceChoices), createMetadata('workspace use', flags));
+                    return;
+                }
+                // Multiple workspaces with same name - prompt user to choose
+                this.log(chalk.yellow(`Multiple workspaces found with name "${input}":`));
+                const { selected } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selected',
+                        message: 'Which workspace do you want to use?',
+                        choices: workspaceChoices,
+                    },
+                ]);
+                workspace = matches.find((w) => w.path === selected);
+            }
+            else {
+                workspace = matches[0];
+            }
+        }
+        // Validate workspace still exists on filesystem
+        if (!fs.existsSync(workspace.path)) {
+            this.error(`Workspace path no longer exists: ${workspace.path}`);
+        }
+        // Validate it's still a valid HQ
+        if (!isValidHQ(workspace.path)) {
+            this.error(`Path is no longer a valid workspace: ${workspace.path}`);
+        }
+        // Set as active workspace
+        try {
+            setActiveWorkspace(workspace.path);
+            this.log(chalk.green(`Active workspace set to: ${workspace.name}`));
+            this.log(chalk.gray(`  Path: ${workspace.path}`));
+        }
+        catch (error) {
+            this.error(`Failed to set active workspace: ${error.message}`);
+        }
+    }
+}

package/dist/hooks/init.d.ts

@@ -0,0 +1,11 @@
+import { Hook } from '@oclif/core';
+/**
+ * Init hook - runs before every command
+ *
+ * Detects first-time users and redirects them to the init flow.
+ * A user is considered "first-time" if:
+ * - No workspaces are registered in machine config (~/.proletariat/config.json)
+ * - AND they're not currently inside a valid HQ directory
+ */
+declare const hook: Hook<'init'>;
+export default hook;

package/dist/hooks/init.js

@@ -0,0 +1,57 @@
+import { readMachineConfig } from '../lib/machine-config.js';
+import { findHQRoot } from '../lib/workspace.js';
+/**
+ * Init hook - runs before every command
+ *
+ * Detects first-time users and redirects them to the init flow.
+ * A user is considered "first-time" if:
+ * - No workspaces are registered in machine config (~/.proletariat/config.json)
+ * - AND they're not currently inside a valid HQ directory
+ */
+const hook = async function ({ id, config }) {
+    // Skip for init command to avoid infinite loop
+    if (id === 'init') {
+        return;
+    }
+    // Skip for help-related commands/flags
+    // When user runs just `prlt` with no args, id is undefined
+    if (!id || id === 'help') {
+        // Check if this is first-time user running bare `prlt`
+        if (!id && isFirstTimeUser()) {
+            // Run init command
+            const { run } = await import('@oclif/core');
+            await run(['init'], config);
+            // Exit after init completes to prevent showing help
+            process.exit(0);
+        }
+        return;
+    }
+    // For all other commands, check if first-time user
+    if (isFirstTimeUser()) {
+        const chalk = await import('chalk');
+        console.log(chalk.default.yellow('\n⚠️  No workspace found. Let\'s set one up first.\n'));
+        // Run init command
+        const { run } = await import('@oclif/core');
+        await run(['init'], config);
+        // Exit after init - user should re-run their original command
+        console.log(chalk.default.blue(`\n✅ Setup complete! You can now run: prlt ${id}\n`));
+        process.exit(0);
+    }
+};
+/**
+ * Check if this is a first-time user (no headquarters configured)
+ */
+function isFirstTimeUser() {
+    // Check if user is currently inside a valid HQ directory
+    const currentHQ = findHQRoot();
+    if (currentHQ) {
+        return false;
+    }
+    // Check if any headquarters are registered in machine config
+    const machineConfig = readMachineConfig();
+    if (machineConfig.headquarters.length > 0) {
+        return false;
+    }
+    return true;
+}
+export default hook;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/agents/commands.d.ts

@@ -0,0 +1,189 @@
+import { Agent, Repository } from '../database/index.js';
+export interface AgentStatus {
+    name: string;
+    exists: boolean;
+    branch?: string;
+    assignedTickets: string[];
+    completedTickets: string[];
+    repositories: {
+        name: string;
+        status: string;
+        commitsAhead: number;
+    }[];
+}
+export interface WorkspaceInfo {
+    path: string;
+    type: 'hq' | 'workspace';
+    workspaceName: string;
+    hasPMO: boolean;
+    agents: Agent[];
+    repositories: Repository[];
+    agentsPath: string;
+    /** Active theme ID (if any) */
+    activeThemeId: string | null;
+    /** Directory name for persistent agents (e.g., 'staff', 'garage', 'portfolio') */
+    persistentAgentsDir: string;
+    /** Directory name for ephemeral agents (e.g., 'temp', 'pit', 'incubator') */
+    ephemeralAgentsDir: string;
+}
+/**
+ * Find workspace root and return workspace information.
+ *
+ * Search priority:
+ * 1. PRLT_HQ_PATH environment variable (ONLY when DEVCONTAINER=true - for devcontainer mounts)
+ * 2. Current directory tree for HQ with workspace.db
+ *
+ * NOTE: PRLT_HQ_PATH is ignored on host machines to support multiple agents
+ * working in different workspaces simultaneously.
+ */
+export declare function getWorkspaceInfo(): WorkspaceInfo;
+/**
+ * Validate agent name
+ */
+export { isValidAgentName } from '../themes.js';
+/**
+ * Get suggested agent names (not yet added to workspace)
+ */
+export declare function getAvailableAgentSuggestions(workspaceInfo: WorkspaceInfo): string[];
+/**
+ * Interactive agent selection - prompts user for agent names
+ */
+export declare function selectAgentsInteractively(workspaceInfo: WorkspaceInfo, message?: string): Promise<string[]>;
+/**
+ * Interactive selection from existing agents
+ */
+export declare function selectExistingAgentsInteractively(workspaceInfo: WorkspaceInfo, message?: string): Promise<string[]>;
+/**
+ * Get detailed status for a specific agent
+ */
+export declare function getAgentStatus(workspaceInfo: WorkspaceInfo, agentName: string): AgentStatus;
+/**
+ * Get status for all agents
+ */
+export declare function getAllAgentsStatus(workspaceInfo: WorkspaceInfo): AgentStatus[];
+/**
+ * Validate agent names (must be valid format)
+ */
+export declare function validateAgentNames(agentNames: string[]): {
+    valid: string[];
+    invalid: string[];
+};
+export interface AddAgentOptions {
+    skipDevcontainer?: boolean;
+    themeId?: string;
+}
+/**
+ * Create agent worktrees and update database
+ */
+export declare function addAgentsToWorkspace(workspaceInfo: WorkspaceInfo, agentNames: string[], options?: AddAgentOptions): Promise<string[]>;
+/**
+ * Remove agents and clean up worktrees
+ */
+export declare function removeAgentsFromWorkspace(workspaceInfo: WorkspaceInfo, agentNames: string[]): Promise<{
+    removed: string[];
+    failed: string[];
+}>;
+export interface EphemeralAgentOptions {
+    themeId?: string;
+    skipDevcontainer?: boolean;
+    /**
+     * Optional logger for conflict messages (e.g., when a tmux session or directory already exists)
+     */
+    log?: (message: string) => void;
+}
+export interface EphemeralAgentResult {
+    name: string;
+    baseName: string;
+    worktreePath: string;
+    agent: Agent;
+}
+/**
+ * Create an ephemeral agent on-demand for a spawn operation.
+ * Creates worktree in agents/temp/{name}/
+ */
+export declare function createEphemeralAgent(workspaceInfo: WorkspaceInfo, options?: EphemeralAgentOptions): Promise<EphemeralAgentResult>;
+/**
+ * Check if a tmux session exists for a given name
+ */
+export declare function tmuxSessionExists(sessionName: string): boolean;
+/**
+ * Get list of active tmux sessions that match our pattern
+ * Pattern: {ticketId}-{action}-{agent}
+ */
+export declare function getActiveTmuxSessions(): Array<{
+    name: string;
+    ticketId: string;
+    agent: string;
+}>;
+/**
+ * Check if there's an active tmux session for a specific ticket
+ */
+export declare function getTicketTmuxSession(ticketId: string): {
+    sessionName: string;
+    agent: string;
+} | null;
+/**
+ * Kill a tmux session by name
+ */
+export declare function killTmuxSession(sessionName: string): boolean;
+export interface CleanupOptions {
+    /** Logger for status messages */
+    log?: (message: string) => void;
+    /** If true, only show what would be cleaned without doing it */
+    dryRun?: boolean;
+    /** If true, skip git safety checks and force cleanup */
+    force?: boolean;
+    /** If true, push unpushed commits before cleanup */
+    pushFirst?: boolean;
+}
+export interface WorktreeGitStatus {
+    worktreePath: string;
+    repoName: string;
+    branch: string;
+    hasUncommittedChanges: boolean;
+    uncommittedFiles: string[];
+    hasUnpushedCommits: boolean;
+    unpushedCount: number;
+}
+export interface AgentGitStatus {
+    agentName: string;
+    worktrees: WorktreeGitStatus[];
+    hasUnsavedWork: boolean;
+}
+export interface CleanupResult {
+    agent: string;
+    success: boolean;
+    tmuxSessionsKilled: string[];
+    containersRemoved: string[];
+    directoriesRemoved: string[];
+    errors: string[];
+    /** Git status if cleanup was blocked due to unsaved work */
+    gitStatus?: AgentGitStatus;
+    /** Whether cleanup was blocked due to unsaved work */
+    blockedByGit?: boolean;
+}
+/**
+ * Get tmux sessions associated with an agent
+ */
+export declare function getAgentTmuxSessions(agentName: string): string[];
+/**
+ * Check git status for all worktrees in an agent directory.
+ * Returns info about uncommitted changes and unpushed commits.
+ */
+export declare function getAgentGitStatus(workspaceInfo: WorkspaceInfo, agentName: string): AgentGitStatus;
+/**
+ * Commit and push all work in an agent's worktrees.
+ * - Stages all uncommitted changes (git add -A)
+ * - Commits with a WIP message if there are staged changes
+ * - Pushes all commits to remote
+ * Returns true if all operations succeeded.
+ */
+export declare function pushAgentWork(workspaceInfo: WorkspaceInfo, agentName: string, log?: (message: string) => void): boolean;
+/**
+ * Clean up a single agent - removes resources but keeps DB record (marked as cleaned)
+ */
+export declare function cleanupAgent(workspaceInfo: WorkspaceInfo, agentName: string, options?: CleanupOptions): Promise<CleanupResult>;
+/**
+ * Get agents that can be cleaned up (active ephemeral agents with no running work)
+ */
+export declare function getCleanableAgents(workspaceInfo: WorkspaceInfo, checkRunning?: boolean): Agent[];