@proletariat/cli 0.2.0 → 0.3.1

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

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Session 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/session/index.js

@@ -0,0 +1,64 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Session extends PMOCommand {
+    static description = 'Manage agent tmux sessions (list, attach, detach)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> list',
+        '<%= config.bin %> <%= command.id %> attach TKT-347-implement',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Session);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices
+        const menuChoices = [
+            { name: 'List active sessions', value: 'list' },
+            { name: 'Attach to a session', value: 'attach' },
+            { name: 'Cancel', value: 'cancel' },
+        ];
+        const message = 'Session Management - What would you like to do?';
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('session', flags));
+            return;
+        }
+        const { action } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: '🖥️  ' + message,
+                choices: [
+                    { name: '📋 ' + menuChoices[0].name, value: menuChoices[0].value },
+                    { name: '🔗 ' + menuChoices[1].name, value: menuChoices[1].value },
+                    new inquirer.Separator(),
+                    { name: '❌ ' + menuChoices[2].name, value: menuChoices[2].value },
+                ],
+            },
+        ]);
+        if (action === 'cancel') {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('session:list', []);
+                break;
+            case 'attach':
+                await this.config.runCommand('session:attach', []);
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Get list of host tmux session names
+     */
+    private getHostTmuxSessionNames;
+    /**
+     * Get map of containerId -> tmux session names
+     */
+    private getContainerTmuxSessionMap;
+}

package/dist/commands/session/list.js

@@ -0,0 +1,181 @@
+import { Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+export default class SessionList extends PMOCommand {
+    static description = 'List active tmux sessions (host and container)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Show all sessions including stale DB records',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(SessionList);
+        // Get workspace info for execution records
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            this.log('');
+            this.log(styles.muted('Not in a workspace. Run from a proletariat HQ directory.'));
+            this.log('');
+            return;
+        }
+        try {
+            // DB-driven approach: Start with executions, verify tmux sessions exist
+            const runningExecutions = executionStorage.listExecutions({ status: 'running' }) || [];
+            const startingExecutions = executionStorage.listExecutions({ status: 'starting' }) || [];
+            const activeExecutions = [...runningExecutions, ...startingExecutions];
+            // Get list of actual tmux sessions for verification
+            const hostTmuxSessions = this.getHostTmuxSessionNames();
+            const containerTmuxSessions = this.getContainerTmuxSessionMap();
+            // Build verified session list from DB records
+            const sessions = [];
+            for (const exec of activeExecutions) {
+                if (!exec.sessionId)
+                    continue; // Skip executions without sessionId
+                const isContainer = exec.environment === 'devcontainer';
+                let exists = false;
+                let containerId;
+                if (isContainer && exec.containerId) {
+                    // Check if session exists in container
+                    const containerSessions = containerTmuxSessions.get(exec.containerId);
+                    exists = containerSessions?.includes(exec.sessionId) ?? false;
+                    containerId = exec.containerId;
+                }
+                else {
+                    // Check if session exists on host
+                    exists = hostTmuxSessions.includes(exec.sessionId);
+                }
+                // Only include if session exists, unless --all flag
+                if (exists || flags.all) {
+                    sessions.push({
+                        sessionId: exec.sessionId,
+                        ticketId: exec.ticketId,
+                        agentName: exec.agentName,
+                        status: exists ? exec.status : 'stale',
+                        environment: isContainer ? 'container' : 'host',
+                        containerId,
+                        exists,
+                    });
+                }
+            }
+            if (sessions.length > 0) {
+                this.log('');
+                this.log(styles.header('🖥️  Active Sessions'));
+                this.log('═'.repeat(90));
+                this.log(styles.muted('  ' +
+                    padEnd('Session', 28) +
+                    padEnd('Ticket', 12) +
+                    padEnd('Agent', 14) +
+                    padEnd('Type', 15) +
+                    'Status'));
+                this.log('  ' + '─'.repeat(80));
+                for (const session of sessions) {
+                    const typeIcon = session.environment === 'container' ? '🐳 container' : '💻 host';
+                    const statusColor = session.status === 'running' ? styles.success :
+                        session.status === 'starting' ? styles.warning :
+                            session.status === 'stale' ? styles.error : styles.muted;
+                    this.log('  ' +
+                        padEnd(session.sessionId, 28) +
+                        padEnd(session.ticketId, 12) +
+                        padEnd(session.agentName, 14) +
+                        padEnd(typeIcon, 15) +
+                        statusColor(session.status));
+                }
+                this.log('');
+                this.log('═'.repeat(90));
+                // Show attach command example
+                const firstSession = sessions.find(s => s.exists);
+                if (firstSession) {
+                    this.log(styles.muted('\nCommands:'));
+                    this.log(styles.muted(`  prlt session attach ${firstSession.sessionId}    Attach to session`));
+                    this.log('');
+                }
+                // Show stale sessions warning
+                const staleSessions = sessions.filter(s => !s.exists);
+                if (staleSessions.length > 0) {
+                    this.log(styles.warning(`\n⚠️  ${staleSessions.length} stale session(s) in DB without tmux process.`));
+                    this.log(styles.muted('   Run `prlt work stop <work-id>` to clean up.'));
+                    this.log('');
+                }
+            }
+            else {
+                this.log('');
+                this.log(styles.muted('No active sessions found.'));
+                this.log('');
+                this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+                this.log('');
+            }
+        }
+        finally {
+            db?.close();
+        }
+    }
+    /**
+     * Get list of host tmux session names
+     */
+    getHostTmuxSessionNames() {
+        try {
+            execSync('which tmux', { stdio: 'pipe' });
+            const output = execSync('tmux list-sessions -F "#{session_name}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (!output)
+                return [];
+            return output.split('\n');
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get map of containerId -> tmux session names
+     */
+    getContainerTmuxSessionMap() {
+        const sessionMap = new Map();
+        try {
+            const containersOutput = execSync('docker ps --filter "label=devcontainer.local_folder" --format "{{.ID}}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (!containersOutput)
+                return sessionMap;
+            for (const containerId of containersOutput.split('\n')) {
+                try {
+                    const tmuxOutput = execSync(`docker exec ${containerId} tmux list-sessions -F "#{session_name}" 2>/dev/null`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+                    if (tmuxOutput) {
+                        sessionMap.set(containerId, tmuxOutput.split('\n'));
+                    }
+                }
+                catch {
+                    // Container has no tmux sessions
+                }
+            }
+        }
+        catch {
+            // Docker not available
+        }
+        return sessionMap;
+    }
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+function padEnd(str, length) {
+    return str.padEnd(length);
+}

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

@@ -0,0 +1,19 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SpecCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        title: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        problem: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private promptSpecData;
+}

package/dist/commands/spec/create.js

@@ -0,0 +1,130 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } 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';
+export default class SpecCreate extends PMOCommand {
+    static description = 'Create a new spec';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "User Authentication"',
+        '<%= config.bin %> <%= command.id %> --title "API Design" --type product',
+        '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+    ];
+    static args = {
+        title: Args.string({
+            description: 'Spec title',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        title: Flags.string({
+            char: 't',
+            description: 'Spec title',
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'Spec status',
+            options: ['draft', 'active', 'implemented'],
+            default: 'draft',
+        }),
+        type: Flags.string({
+            description: 'Spec type',
+            options: ['product', 'platform', 'infra', 'integration'],
+        }),
+        problem: Flags.string({
+            description: 'Problem statement',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecCreate);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Get spec data
+        let specData;
+        if (flags.interactive || (!args.title && !flags.title)) {
+            // Build choices once - single source of truth
+            const typeChoices = [
+                { name: 'Product (user-facing feature)', value: 'product' },
+                { name: 'Platform (internal tooling)', value: 'platform' },
+                { name: 'Infra (technical infrastructure)', value: 'infra' },
+                { name: 'Integration (external service)', value: 'integration' },
+                { name: 'None', value: '' },
+            ];
+            const statusChoices = [
+                { name: 'Draft (planning)', value: 'draft' },
+                { name: 'Active (in progress)', value: 'active' },
+                { name: 'Implemented (complete)', value: 'implemented' },
+            ];
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'title', message: 'Spec title:', default: flags.title },
+                { type: 'list', name: 'type', message: 'Spec type:', choices: typeChoices, default: flags.type },
+                { type: 'list', name: 'status', message: 'Status:', choices: statusChoices, default: flags.status || 'draft' },
+                { type: 'input', name: 'problem', message: 'Problem statement (optional):', default: flags.problem },
+            ];
+            // In JSON mode, output form prompts
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('spec create', flags));
+            }
+            specData = await this.promptSpecData(fields);
+        }
+        else {
+            specData = {
+                title: args.title || flags.title || 'Untitled Spec',
+                status: flags.status || 'draft',
+                type: flags.type,
+                problem: flags.problem,
+            };
+        }
+        // Generate ID from title
+        const specId = slugify(specData.title);
+        // Create spec in database
+        const spec = await this.storage.createSpec({
+            id: specId,
+            title: specData.title,
+            status: specData.status,
+            type: specData.type,
+            problem: specData.problem,
+        });
+        this.log(styles.success(`\n✅ Created spec "${styles.emphasis(spec.title)}"`));
+        this.log(styles.muted(`  ID: ${spec.id}`));
+        this.log(styles.muted(`  Status: ${spec.status}`));
+        if (spec.type)
+            this.log(styles.muted(`  Type: ${spec.type}`));
+        this.log(styles.muted(`\nNext steps:`));
+        this.log(styles.muted(`  1. prlt spec view ${spec.id}`));
+        this.log(styles.muted(`  2. prlt spec edit ${spec.id}  (to add details)`));
+        this.log(styles.muted(`  3. prlt spec plan ${spec.id}  (to generate tickets)`));
+    }
+    async promptSpecData(fields) {
+        // Build inquirer prompts from fields, adding validators
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            // Convert empty string value to undefined for 'type' field
+            choices: field.name === 'type' && field.choices
+                ? field.choices.map(c => ({ ...c, value: c.value || undefined }))
+                : field.choices,
+            // Add validator for required title field
+            validate: field.name === 'title'
+                ? ((input) => input.length > 0 || 'Title is required')
+                : undefined,
+        })));
+        return {
+            title: answers.title,
+            status: answers.status,
+            type: answers.type,
+            problem: answers.problem || undefined,
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Spec 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/spec/index.js

@@ -0,0 +1,68 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Spec extends PMOCommand {
+    static description = 'Interactive menu for spec operations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Spec);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'create', name: 'Create new spec', command: 'prlt spec create --json' },
+            { id: 'list', name: 'List all specs', command: 'prlt spec list --format json' },
+            { id: 'view', name: 'View spec', command: 'prlt spec view --json' },
+            { id: 'generate', name: 'Generate tickets from spec', command: 'prlt spec plan --json' },
+            { id: 'ticket', name: 'Assign ticket to spec', command: 'prlt spec ticket --json' },
+            { id: 'link', name: 'Manage dependencies', command: 'prlt spec link --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Spec Operations - What would you like to do?';
+        const action = await this.selectFromList({
+            message: '📄 ' + message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'spec' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'create':
+                await this.config.runCommand('spec:create', []);
+                break;
+            case 'list':
+                await this.config.runCommand('spec:list', []);
+                break;
+            case 'view':
+                await this.config.runCommand('spec:view', []);
+                break;
+            case 'generate':
+                await this.config.runCommand('spec:generate-tickets', []);
+                break;
+            case 'ticket':
+                await this.config.runCommand('spec:ticket', []);
+                break;
+            case 'link':
+                await this.config.runCommand('spec:link', []);
+                break;
+        }
+    }
+}

package/dist/commands/spec/link/depends.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class SpecLinkDepends extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/spec/link/depends.js

@@ -0,0 +1,64 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class SpecLinkDepends extends PMOCommand {
+    static description = 'Add a depends_on dependency (spec requires another to be completed first)';
+    static examples = ['<%= config.bin %> <%= command.id %> my-feature other-spec'];
+    static args = {
+        id: Args.string({ description: 'Spec ID that depends on another', required: true }),
+        target: Args.string({ description: 'Spec ID that this spec depends on', required: false }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecLinkDepends);
+        // 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('spec link depends', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const spec = await this.storage.getSpec(args.id);
+        if (!spec)
+            return handleError('SPEC_NOT_FOUND', `Spec not found: ${args.id}`);
+        let targetId = args.target;
+        if (!targetId) {
+            const allSpecs = await this.storage.listSpecs();
+            const otherSpecs = allSpecs.filter(s => s.id !== args.id);
+            if (otherSpecs.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_OTHER_SPECS', 'No other specs.', createMetadata('spec link depends', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo other specs.'));
+                return;
+            }
+            // In JSON mode, output spec selection prompt
+            if (jsonMode) {
+                const specChoices = otherSpecs.map(s => ({ name: `${s.id} - ${s.title}`, value: s.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'target', `Select spec that ${args.id} depends on:`, specChoices), createMetadata('spec link depends', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{ type: 'list', name: 'selected', message: `Select spec that ${args.id} depends on:`,
+                    choices: otherSpecs.map(s => ({ name: `${s.id} - ${s.title}`, value: s.id })) }]);
+            targetId = selected;
+        }
+        const targetSpec = await this.storage.getSpec(targetId);
+        if (!targetSpec)
+            this.error(`Spec not found: ${targetId}`);
+        await this.storage.createSpecDependency(args.id, targetId, 'depends_on');
+        this.log(styles.success(`\n✅ ${styles.emphasis(args.id)} depends on ${styles.emphasis(targetId)}`));
+        this.log(styles.muted(`   ${spec.title} depends on: ${targetSpec.title}`));
+    }
+}

package/dist/commands/spec/link/duplicates.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class SpecLinkDuplicates extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        original: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}