@proletariat/cli 0.3.50 → 0.3.52

package/dist/commands/agent/status.js

@@ -42,6 +42,7 @@ export default class Status extends PMOCommand {
             outputSuccessAsJson({
                 agents: allStatuses,
             }, createMetadata('agent status', flags));
+            return;
         }
         // Agent mode config for prompts
         const agentConfig = jsonMode ? { flags, commandName: 'agent status' } : null;

package/dist/commands/asana/connect.d.ts

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class AsanaConnect extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        disconnect: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/asana/connect.js

@@ -0,0 +1,267 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { AsanaClient, clearAsanaConfig, getAsanaAccessToken, isAsanaConfigured, loadAsanaConfig, saveAsanaAccessToken, saveAsanaProject, saveAsanaWorkspace, } from '../../lib/asana/index.js';
+function isLikelyGid(value) {
+    return /^\d+$/.test(value);
+}
+export default class AsanaConnect extends PMOCommand {
+    static description = 'Authenticate with Asana and configure workspace/project defaults';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --check',
+        '<%= config.bin %> <%= command.id %> --workspace "Product Team" --project "Roadmap"',
+        'ASANA_ACCESS_TOKEN=... <%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        check: Flags.boolean({
+            description: 'Only check if Asana credentials exist (do not prompt)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Force re-authentication even if credentials exist',
+            default: false,
+        }),
+        disconnect: Flags.boolean({
+            description: 'Remove stored Asana credentials',
+            default: false,
+        }),
+        workspace: Flags.string({
+            description: 'Default workspace gid or name',
+        }),
+        project: Flags.string({
+            description: 'Default project gid or name',
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(AsanaConnect);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (flags.disconnect) {
+            clearAsanaConfig(db);
+            if (jsonMode) {
+                outputSuccessAsJson({ disconnected: true, message: 'Asana credentials removed.' }, createMetadata('asana connect', flags));
+                return;
+            }
+            this.log(colors.success('Asana credentials removed.'));
+            return;
+        }
+        if (flags.check) {
+            if (!isAsanaConfigured(db)) {
+                if (jsonMode) {
+                    outputErrorAsJson('ASANA_NOT_CONFIGURED', 'Asana is not configured. Run "prlt asana connect".', createMetadata('asana connect', flags));
+                    this.exit(1);
+                }
+                this.log(colors.warning('Asana is not configured.'));
+                this.log(colors.textMuted('Run "prlt asana connect" to authenticate.'));
+                this.exit(1);
+            }
+            const config = loadAsanaConfig(db);
+            try {
+                const client = new AsanaClient(config.accessToken);
+                const user = await client.verify();
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        authenticated: true,
+                        user: user.name,
+                        email: user.email ?? null,
+                        workspace: config.workspaceName ?? config.workspaceGid ?? null,
+                        project: config.projectName ?? config.projectGid ?? null,
+                    }, createMetadata('asana connect', flags));
+                    return;
+                }
+                this.log(colors.success('Asana connection is active'));
+                this.log(colors.textMuted(`  User: ${user.name}${user.email ? ` (${user.email})` : ''}`));
+                if (config.workspaceName || config.workspaceGid) {
+                    this.log(colors.textMuted(`  Workspace: ${config.workspaceName ?? config.workspaceGid}`));
+                }
+                if (config.projectName || config.projectGid) {
+                    this.log(colors.textMuted(`  Project: ${config.projectName ?? config.projectGid}`));
+                }
+            }
+            catch {
+                if (jsonMode) {
+                    outputErrorAsJson('ASANA_AUTH_INVALID', 'Stored Asana token is invalid or expired.', createMetadata('asana connect', flags));
+                    this.exit(1);
+                }
+                this.log(colors.error('Stored Asana token is invalid or expired.'));
+                this.log(colors.textMuted('Run "prlt asana connect --force" to re-authenticate.'));
+                this.exit(1);
+            }
+            return;
+        }
+        const existingConfig = loadAsanaConfig(db);
+        if (existingConfig && !flags.force) {
+            try {
+                const client = new AsanaClient(existingConfig.accessToken);
+                const user = await client.verify();
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        authenticated: true,
+                        user: user.name,
+                        message: 'Already authenticated. Use --force to re-authenticate.',
+                    }, createMetadata('asana connect', flags));
+                    return;
+                }
+                this.log(colors.success('Already connected to Asana'));
+                this.log(colors.textMuted(`  User: ${user.name}`));
+                this.log(colors.textMuted('Use --force to re-authenticate.'));
+                return;
+            }
+            catch {
+                // Continue to re-authenticate with a new token
+            }
+        }
+        let accessToken = getAsanaAccessToken(db);
+        if (!accessToken) {
+            if (jsonMode) {
+                outputErrorAsJson('ACCESS_TOKEN_REQUIRED', 'Asana access token required. Set ASANA_ACCESS_TOKEN or PRLT_ASANA_ACCESS_TOKEN.', createMetadata('asana connect', flags));
+                this.exit(1);
+            }
+            this.log('');
+            this.log(colors.primary('Asana Authentication'));
+            this.log('');
+            this.log('Create a Personal Access Token at:');
+            this.log(colors.textSecondary('  https://app.asana.com/0/my-apps'));
+            this.log('');
+            const { inputToken } = await inquirer.prompt([{
+                    type: 'password',
+                    name: 'inputToken',
+                    message: 'Enter your Asana access token:',
+                    mask: '*',
+                    validate: (input) => input.trim().length > 0 || 'Access token is required',
+                }]);
+            accessToken = inputToken;
+        }
+        if (!accessToken) {
+            if (jsonMode) {
+                outputErrorAsJson('ACCESS_TOKEN_REQUIRED', 'Asana access token required. Set ASANA_ACCESS_TOKEN or PRLT_ASANA_ACCESS_TOKEN.', createMetadata('asana connect', flags));
+            }
+            else {
+                this.log(colors.error('Asana access token is required.'));
+            }
+            this.exit(1);
+        }
+        this.log('');
+        this.log(colors.textMuted('Verifying Asana access token...'));
+        if (!accessToken) {
+            if (jsonMode) {
+                outputErrorAsJson('ACCESS_TOKEN_REQUIRED', 'Asana access token required. Set ASANA_ACCESS_TOKEN or PRLT_ASANA_ACCESS_TOKEN.', createMetadata('asana connect', flags));
+                this.exit(1);
+            }
+            this.log(colors.error('Asana access token is required.'));
+            this.exit(1);
+        }
+        const client = new AsanaClient(accessToken);
+        try {
+            const user = await client.verify();
+            saveAsanaAccessToken(db, accessToken);
+            let workspaceGid;
+            let workspaceName;
+            let projectGid;
+            let projectName;
+            if (flags.workspace) {
+                const workspaces = user.workspaces;
+                if (isLikelyGid(flags.workspace)) {
+                    const workspace = await client.getWorkspace(flags.workspace);
+                    if (!workspace) {
+                        throw new Error(`Workspace ${flags.workspace} not found`);
+                    }
+                    workspaceGid = workspace.gid;
+                    workspaceName = workspace.name;
+                }
+                else {
+                    const matched = workspaces.find((workspace) => workspace.name.toLowerCase() === flags.workspace.toLowerCase());
+                    if (!matched) {
+                        throw new Error(`Workspace "${flags.workspace}" not found`);
+                    }
+                    workspaceGid = matched.gid;
+                    workspaceName = matched.name;
+                }
+            }
+            else if (!jsonMode && user.workspaces.length === 1) {
+                workspaceGid = user.workspaces[0].gid;
+                workspaceName = user.workspaces[0].name;
+            }
+            if (!workspaceGid && !jsonMode && user.workspaces.length > 1) {
+                const { selectedWorkspace } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedWorkspace',
+                        message: 'Select default Asana workspace (optional):',
+                        choices: [
+                            { name: 'Skip', value: null },
+                            ...user.workspaces.map((workspace) => ({
+                                name: workspace.name,
+                                value: workspace.gid,
+                            })),
+                        ],
+                        default: null,
+                    }]);
+                if (selectedWorkspace) {
+                    const selected = user.workspaces.find((workspace) => workspace.gid === selectedWorkspace);
+                    workspaceGid = selected?.gid;
+                    workspaceName = selected?.name;
+                }
+            }
+            if (workspaceGid) {
+                saveAsanaWorkspace(db, workspaceGid, workspaceName ?? workspaceGid);
+            }
+            if (flags.project) {
+                const projectScope = workspaceGid ?? loadAsanaConfig(db)?.workspaceGid;
+                if (isLikelyGid(flags.project)) {
+                    const project = await client.getProject(flags.project);
+                    if (!project) {
+                        throw new Error(`Project ${flags.project} not found`);
+                    }
+                    projectGid = project.gid;
+                    projectName = project.name;
+                }
+                else if (projectScope) {
+                    const projects = await client.listProjects(projectScope);
+                    const matched = projects.find((project) => project.name.toLowerCase() === flags.project.toLowerCase());
+                    if (!matched) {
+                        throw new Error(`Project "${flags.project}" not found in selected workspace`);
+                    }
+                    projectGid = matched.gid;
+                    projectName = matched.name;
+                }
+                else {
+                    throw new Error('A workspace must be configured before selecting a project by name.');
+                }
+            }
+            if (projectGid) {
+                saveAsanaProject(db, projectGid, projectName ?? projectGid);
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    authenticated: true,
+                    user: user.name,
+                    email: user.email ?? null,
+                    workspace: workspaceName ?? null,
+                    project: projectName ?? null,
+                }, createMetadata('asana connect', flags));
+                return;
+            }
+            this.log(colors.success('Connected to Asana'));
+            this.log(colors.textMuted(`  User: ${user.name}${user.email ? ` (${user.email})` : ''}`));
+            if (workspaceName) {
+                this.log(colors.textMuted(`  Workspace: ${workspaceName}`));
+            }
+            if (projectName) {
+                this.log(colors.textMuted(`  Project: ${projectName}`));
+            }
+            this.log('');
+            this.log(colors.textMuted('Run "prlt asana sync" to sync mapped tickets to Asana tasks.'));
+        }
+        catch (error) {
+            if (jsonMode) {
+                outputErrorAsJson('ASANA_CONNECT_FAILED', `Connection failed: ${error instanceof Error ? error.message : String(error)}`, createMetadata('asana connect', flags));
+                this.exit(1);
+            }
+            this.error(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/commands/asana/sync.d.ts

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class AsanaSyncCommand extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'create-missing': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/asana/sync.js

@@ -0,0 +1,189 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { AsanaClient, AsanaMapper, AsanaSync, isAsanaConfigured, loadAsanaConfig, } from '../../lib/asana/index.js';
+export default class AsanaSyncCommand extends PMOCommand {
+    static description = 'Sync PMO tickets to Asana tasks';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001 --task 123456789',
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001 --create-missing',
+        '<%= config.bin %> <%= command.id %> --dry-run',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        ticket: Flags.string({
+            description: 'PMO ticket ID to sync (syncs all mapped tickets if omitted)',
+        }),
+        task: Flags.string({
+            description: 'Asana task gid to map to --ticket',
+        }),
+        project: Flags.string({
+            description: 'Asana project gid used with --create-missing',
+        }),
+        'create-missing': Flags.boolean({
+            description: 'Create Asana task when no mapping exists (requires project)',
+            default: false,
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview sync operations without making changes',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(AsanaSyncCommand);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isAsanaConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('ASANA_NOT_CONFIGURED', 'Asana is not configured. Run "prlt asana connect" first.', createMetadata('asana sync', flags));
+                this.exit(1);
+            }
+            this.error('Asana is not configured. Run "prlt asana connect" first.');
+        }
+        const config = loadAsanaConfig(db);
+        const client = new AsanaClient(config.accessToken);
+        const mapper = new AsanaMapper(db);
+        const sync = new AsanaSync(client, mapper);
+        if (flags.ticket) {
+            const ticket = await this.storage.getTicket(flags.ticket);
+            if (!ticket) {
+                if (jsonMode) {
+                    outputErrorAsJson('TICKET_NOT_FOUND', `Ticket ${flags.ticket} not found.`, createMetadata('asana sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Ticket ${flags.ticket} not found.`);
+            }
+            if (flags.task) {
+                mapper.createOrUpdateMapping(flags.ticket, flags.task, flags.project ?? config.projectGid);
+            }
+            const mapping = mapper.getByTicketId(flags.ticket);
+            if (!mapping) {
+                if (!flags['create-missing']) {
+                    if (jsonMode) {
+                        outputSuccessAsJson({
+                            synced: false,
+                            message: `Ticket ${flags.ticket} has no Asana mapping. Use --task or --create-missing.`,
+                        }, createMetadata('asana sync', flags));
+                        return;
+                    }
+                    this.log(colors.warning(`Ticket ${flags.ticket} has no Asana mapping. Use --task or --create-missing.`));
+                    return;
+                }
+                const projectGid = flags.project ?? config.projectGid;
+                if (!projectGid) {
+                    if (jsonMode) {
+                        outputErrorAsJson('ASANA_PROJECT_REQUIRED', 'Project gid is required for --create-missing. Use --project or run "prlt asana connect --project ...".', createMetadata('asana sync', flags));
+                        this.exit(1);
+                    }
+                    this.error('Project gid is required for --create-missing. Use --project or run "prlt asana connect --project ...".');
+                }
+                if (flags['dry-run']) {
+                    if (jsonMode) {
+                        outputSuccessAsJson({
+                            dryRun: true,
+                            action: 'create-and-sync',
+                            ticketId: flags.ticket,
+                            projectGid,
+                        }, createMetadata('asana sync', flags));
+                        return;
+                    }
+                    this.log(colors.textMuted(`Would create Asana task in project ${projectGid} for ${flags.ticket}`));
+                    return;
+                }
+                const taskGid = await sync.createTaskForTicket(ticket, projectGid);
+                await sync.syncTicket(ticket, taskGid);
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        action: 'create-and-sync',
+                        ticketId: flags.ticket,
+                        asanaTaskGid: taskGid,
+                        synced: true,
+                    }, createMetadata('asana sync', flags));
+                    return;
+                }
+                this.log(colors.success(`Created and synced Asana task ${taskGid} for ${flags.ticket}`));
+                return;
+            }
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'sync-ticket',
+                        ticketId: flags.ticket,
+                        asanaTaskGid: mapping.asanaTaskGid,
+                        statusCategory: ticket.statusCategory,
+                    }, createMetadata('asana sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would sync ${flags.ticket} to Asana task ${mapping.asanaTaskGid}`));
+                return;
+            }
+            await sync.syncTicket(ticket, mapping.asanaTaskGid);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'sync-ticket',
+                    ticketId: flags.ticket,
+                    asanaTaskGid: mapping.asanaTaskGid,
+                    synced: true,
+                }, createMetadata('asana sync', flags));
+                return;
+            }
+            this.log(colors.success(`Synced ${flags.ticket} to Asana task ${mapping.asanaTaskGid}`));
+            return;
+        }
+        const mappings = mapper.listMappings();
+        if (mappings.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({ synced: 0, skipped: 0, errors: 0, message: 'No mapped tickets to sync.' }, createMetadata('asana sync', flags));
+                return;
+            }
+            this.log(colors.textMuted('No mapped tickets to sync.'));
+            return;
+        }
+        if (flags['dry-run']) {
+            const preview = [];
+            for (const mapping of mappings) {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(mapping.pmoTicketId);
+                preview.push({
+                    ticketId: mapping.pmoTicketId,
+                    asanaTaskGid: mapping.asanaTaskGid,
+                    statusCategory: ticket?.statusCategory ?? null,
+                });
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({ dryRun: true, action: 'sync-all', tickets: preview }, createMetadata('asana sync', flags));
+                return;
+            }
+            for (const item of preview) {
+                this.log(colors.textMuted(`  ${item.ticketId} -> ${item.asanaTaskGid} (${item.statusCategory ?? 'missing'})`));
+            }
+            return;
+        }
+        let synced = 0;
+        let skipped = 0;
+        let errors = 0;
+        for (const mapping of mappings) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(mapping.pmoTicketId);
+                if (!ticket) {
+                    skipped++;
+                    continue;
+                }
+                // eslint-disable-next-line no-await-in-loop
+                await sync.syncTicket(ticket, mapping.asanaTaskGid);
+                synced++;
+            }
+            catch {
+                errors++;
+            }
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({ action: 'sync-all', synced, skipped, errors }, createMetadata('asana sync', flags));
+            return;
+        }
+        this.log(colors.success(`Asana sync complete: ${synced} synced, ${skipped} skipped, ${errors} errors`));
+    }
+}

package/dist/commands/config/index.js

@@ -6,7 +6,7 @@ import { PromptCommand } from '../../lib/prompt-command.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
-import { loadExecutionConfig, saveTerminalApp, saveTerminalOpenInBackground, saveTmuxControlMode, saveShell, saveCreatePrDefault, saveFirewallAllowlistDomains, } from '../../lib/execution/config.js';
+import { loadExecutionConfig, saveTerminalApp, saveTerminalOpenInBackground, saveTmuxControlMode, saveShell, getMirrorToPmoDefault, saveCreatePrDefault, saveMirrorToPmoDefault, saveFirewallAllowlistDomains, } from '../../lib/execution/config.js';
 import { shouldOutputJson, isNonTTY, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class Config extends PromptCommand {
     static description = 'View and update workspace configuration';
@@ -56,6 +56,7 @@ export default class Config extends PromptCommand {
         try {
             // Load current config
             const config = loadExecutionConfig(db);
+            const mirrorToPmoDefault = getMirrorToPmoDefault(db);
             // Handle --set flag
             if (flags.set && flags.set.length > 0) {
                 for (const setValue of flags.set) {
@@ -94,6 +95,7 @@ export default class Config extends PromptCommand {
                         outputMode: config.outputMode,
                         permissionMode: config.permissionMode,
                         createPrDefault: config.createPrDefault ?? null,
+                        mirrorToPmoDefault,
                         firewall: {
                             allowlistDomains: config.firewall.allowlistDomains,
                         },
@@ -120,6 +122,7 @@ export default class Config extends PromptCommand {
                     this.log(`  outputMode:       ${config.outputMode}`);
                     this.log(`  permissionMode:   ${config.permissionMode}`);
                     this.log(`  createPrDefault:  ${config.createPrDefault ?? 'not set (will prompt)'}`);
+                    this.log(`  mirrorToPmoDefault: ${mirrorToPmoDefault ?? 'not set (default: true)'}`);
                     this.log(`  firewall.allowlistDomains: ${config.firewall.allowlistDomains.join(', ') || '(none)'}`);
                     this.log('');
                 }
@@ -300,6 +303,9 @@ export default class Config extends PromptCommand {
             case 'execution.create_pr_default':
                 saveCreatePrDefault(db, value.toLowerCase() === 'true');
                 break;
+            case 'execution.mirror_to_pmo_default':
+                saveMirrorToPmoDefault(db, value.toLowerCase() === 'true');
+                break;
             case 'firewall.allowlistdomains': {
                 const domains = value
                     .split(',')

package/dist/commands/execution/list.js

@@ -52,6 +52,9 @@ export default class ExecutionList extends PMOCommand {
         const db = new Database(dbPath);
         const executionStorage = new ExecutionStorage(db);
         try {
+            // Keep execution status truthful: mark missing tmux/container sessions as stopped
+            // before listing so "running" only reflects actually active work.
+            executionStorage.cleanupStaleExecutions();
             const executions = executionStorage.listExecutions({
                 status: flags.status,
                 agentName: flags.agent,

package/dist/commands/execution/view.js

@@ -101,6 +101,10 @@ export default class ExecutionView extends PMOCommand {
                     sessionId: execution.sessionId || null,
                     host: execution.host || null,
                     logPath: execution.logPath || null,
+                    externalSource: execution.externalSource || null,
+                    externalKey: execution.externalKey || null,
+                    externalId: execution.externalId || null,
+                    externalUrl: execution.externalUrl || null,
                     startedAt: execution.startedAt.toISOString(),
                     completedAt: execution.completedAt?.toISOString() || null,
                     exitCode: execution.exitCode ?? null,
@@ -128,6 +132,12 @@ export default class ExecutionView extends PMOCommand {
             if (execution.branch) {
                 this.log(`${styles.muted('Branch:')}       ${execution.branch}`);
             }
+            if (execution.externalSource || execution.externalKey) {
+                this.log(`${styles.muted('External:')}     ${(execution.externalSource || 'unknown')} ${execution.externalKey ? `(${execution.externalKey})` : ''}`.trimEnd());
+                if (execution.externalUrl) {
+                    this.log(`${styles.muted('External URL:')} ${execution.externalUrl}`);
+                }
+            }
             this.log('');
             // Process info
             if (execution.pid || execution.containerId || execution.sessionId || execution.host) {

package/dist/commands/monday/connect.d.ts

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class MondayConnect extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        board: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        disconnect: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private checkConnection;
+}