@proletariat/cli 0.3.45 → 0.3.46

package/dist/commands/linear/status.js

@@ -0,0 +1,88 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { LinearClient, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+import { LinearMapper } from '../../lib/linear/mapper.js';
+export default class LinearStatus extends PMOCommand {
+    static description = 'Show Linear integration status and connection info';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearStatus);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    configured: false,
+                    message: 'Linear is not configured. Run "prlt linear auth" to connect.',
+                }, createMetadata('linear status', flags));
+                return;
+            }
+            this.log(colors.warning('Linear is not configured'));
+            this.log(colors.textMuted('Run "prlt linear auth" to connect your Linear workspace.'));
+            return;
+        }
+        const config = loadLinearConfig(db);
+        // Verify connection
+        let connectionInfo = null;
+        let connectionError = null;
+        try {
+            const client = new LinearClient(config.apiKey);
+            connectionInfo = await client.verify();
+        }
+        catch (error) {
+            connectionError = error instanceof Error ? error.message : String(error);
+        }
+        // Count mapped issues
+        const mapper = new LinearMapper(db);
+        const mappings = mapper.listMappings();
+        if (jsonMode) {
+            outputSuccessAsJson({
+                configured: true,
+                connected: connectionInfo !== null,
+                organization: connectionInfo?.organizationName ?? config.organizationName ?? null,
+                user: connectionInfo?.userName ?? null,
+                email: connectionInfo?.email ?? null,
+                defaultTeam: config.defaultTeamKey ?? null,
+                mappedIssues: mappings.length,
+                error: connectionError,
+            }, createMetadata('linear status', flags));
+            return;
+        }
+        this.log(colors.primary('Linear Integration Status'));
+        this.log('');
+        if (connectionInfo) {
+            this.log(`  ${colors.success('Connected')}`);
+            this.log(colors.textMuted(`  Organization: ${connectionInfo.organizationName}`));
+            this.log(colors.textMuted(`  User: ${connectionInfo.userName} (${connectionInfo.email})`));
+        }
+        else {
+            this.log(`  ${colors.error('Connection failed')}`);
+            if (connectionError) {
+                this.log(colors.textMuted(`  Error: ${connectionError}`));
+            }
+        }
+        if (config.defaultTeamKey) {
+            this.log(colors.textMuted(`  Default team: ${config.defaultTeamKey}`));
+        }
+        this.log('');
+        this.log(colors.textMuted(`  Mapped issues: ${mappings.length}`));
+        if (mappings.length > 0) {
+            const recent = mappings.slice(0, 5);
+            this.log('');
+            this.log(colors.textMuted('  Recent mappings:'));
+            for (const m of recent) {
+                this.log(colors.textMuted(`    ${m.linearIdentifier} → ${m.pmoTicketId}`));
+            }
+            if (mappings.length > 5) {
+                this.log(colors.textMuted(`    ... and ${mappings.length - 5} more`));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-title': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': 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>;
+}

package/dist/commands/linear/sync.js

@@ -0,0 +1,233 @@
+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 { LinearClient, LinearMapper, LinearSync, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description = 'Sync PMO ticket status and PR links back to Linear';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>                    # Sync all mapped tickets',
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001   # Sync a specific ticket',
+        '<%= config.bin %> <%= command.id %> --pr-url https://github.com/... --ticket TKT-001  # Attach PR to Linear issue',
+        '<%= config.bin %> <%= command.id %> --dry-run          # Preview what would be synced',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        ticket: Flags.string({
+            description: 'PMO ticket ID to sync (syncs all if omitted)',
+        }),
+        'pr-url': Flags.string({
+            description: 'PR URL to attach to the Linear issue',
+        }),
+        'pr-title': Flags.string({
+            description: 'PR title for the attachment (defaults to ticket title)',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview what would be synced without making changes',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearSyncCommand);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.', createMetadata('linear sync', flags));
+                this.exit(1);
+            }
+            this.error('Linear is not configured. Run "prlt linear auth" first.');
+        }
+        const config = loadLinearConfig(db);
+        const client = new LinearClient(config.apiKey);
+        const mapper = new LinearMapper(db);
+        const sync = new LinearSync(client, mapper);
+        // Handle PR link attachment
+        if (flags['pr-url'] && flags.ticket) {
+            const prTitle = flags['pr-title'] ?? (await this.storage.getTicket(flags.ticket))?.title ?? 'Pull Request';
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'attach-pr',
+                        ticketId: flags.ticket,
+                        prUrl: flags['pr-url'],
+                        prTitle,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would attach PR to ${flags.ticket}: ${flags['pr-url']}`));
+                return;
+            }
+            const attached = await sync.syncPRLink(flags.ticket, flags['pr-url'], prTitle);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'attach-pr',
+                    ticketId: flags.ticket,
+                    prUrl: flags['pr-url'],
+                    synced: attached,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (attached) {
+                this.log(colors.success(`PR linked to Linear issue for ${flags.ticket}`));
+            }
+            else {
+                this.log(colors.warning(`No Linear mapping found for ${flags.ticket}`));
+            }
+            return;
+        }
+        // Sync ticket status(es) back to Linear
+        if (flags.ticket) {
+            // Single ticket sync
+            const ticket = await this.storage.getTicket(flags.ticket);
+            if (!ticket) {
+                if (jsonMode) {
+                    outputErrorAsJson('TICKET_NOT_FOUND', `Ticket ${flags.ticket} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Ticket ${flags.ticket} not found.`);
+            }
+            const mapping = mapper.getByTicketId(flags.ticket);
+            if (!mapping) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        synced: false,
+                        message: `Ticket ${flags.ticket} has no Linear mapping.`,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.warning(`Ticket ${flags.ticket} has no Linear mapping.`));
+                return;
+            }
+            // Get Linear states for the team
+            const team = await client.getTeamByKey(mapping.linearTeamKey);
+            if (!team) {
+                if (jsonMode) {
+                    outputErrorAsJson('TEAM_NOT_FOUND', `Linear team ${mapping.linearTeamKey} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Linear team ${mapping.linearTeamKey} not found.`);
+            }
+            const linearStates = await client.listStates(team.id);
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'sync-status',
+                        ticketId: flags.ticket,
+                        linearIdentifier: mapping.linearIdentifier,
+                        currentStatus: ticket.statusName,
+                        statusCategory: ticket.statusCategory,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would sync ${flags.ticket} (${mapping.linearIdentifier}): status "${ticket.statusName}" (${ticket.statusCategory})`));
+                return;
+            }
+            const synced = await sync.syncTicketStatus(ticket, linearStates);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'sync-status',
+                    ticketId: flags.ticket,
+                    linearIdentifier: mapping.linearIdentifier,
+                    synced,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (synced) {
+                this.log(colors.success(`Synced ${mapping.linearIdentifier} status to Linear`));
+            }
+            else {
+                this.log(colors.warning(`Could not find matching Linear state for ${ticket.statusCategory}`));
+            }
+            return;
+        }
+        // Bulk sync: sync all mapped tickets
+        const mappings = mapper.listMappings();
+        if (mappings.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    synced: 0,
+                    message: 'No mapped tickets to sync.',
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log(colors.textMuted('No mapped tickets to sync.'));
+            return;
+        }
+        if (!jsonMode) {
+            this.log(colors.textMuted(`Syncing ${mappings.length} mapped ticket(s) to Linear...`));
+        }
+        // Group mappings by team to fetch states efficiently
+        const teamKeys = [...new Set(mappings.map((m) => m.linearTeamKey))];
+        const statesByTeam = {};
+        for (const teamKey of teamKeys) {
+            // eslint-disable-next-line no-await-in-loop
+            const team = await client.getTeamByKey(teamKey);
+            if (team) {
+                // eslint-disable-next-line no-await-in-loop
+                statesByTeam[teamKey] = await client.listStates(team.id);
+            }
+        }
+        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,
+                    linearIdentifier: mapping.linearIdentifier,
+                    currentStatus: ticket?.statusName,
+                    statusCategory: ticket?.statusCategory,
+                });
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    action: 'sync-all',
+                    tickets: preview,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log('');
+            for (const item of preview) {
+                this.log(colors.textMuted(`  ${item.linearIdentifier} → ${item.currentStatus} (${item.statusCategory})`));
+            }
+            return;
+        }
+        // Perform the sync for each team
+        let totalSynced = 0;
+        let totalSkipped = 0;
+        let totalErrors = 0;
+        for (const teamKey of teamKeys) {
+            const teamStates = statesByTeam[teamKey];
+            if (!teamStates) {
+                totalErrors += mappings.filter((m) => m.linearTeamKey === teamKey).length;
+                continue;
+            }
+            const teamMappings = mappings.filter((m) => m.linearTeamKey === teamKey);
+            // eslint-disable-next-line no-await-in-loop
+            const result = await sync.syncAllStatuses(this.storage, teamMappings, teamStates);
+            totalSynced += result.synced;
+            totalSkipped += result.skipped;
+            totalErrors += result.errors;
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                action: 'sync-all',
+                synced: totalSynced,
+                skipped: totalSkipped,
+                errors: totalErrors,
+            }, createMetadata('linear sync', flags));
+            return;
+        }
+        this.log('');
+        if (totalSynced > 0)
+            this.log(colors.success(`Synced: ${totalSynced}`));
+        if (totalSkipped > 0)
+            this.log(colors.textMuted(`Skipped: ${totalSkipped}`));
+        if (totalErrors > 0)
+            this.log(colors.error(`Errors: ${totalErrors}`));
+    }
+}

package/dist/commands/orchestrator/attach.d.ts

@@ -1,13 +1,21 @@
 import { PromptCommand } from '../../lib/prompt-command.js';
+/**
+ * Detect the terminal emulator from environment variables.
+ * Returns a terminal app name suitable for AppleScript tab creation,
+ * or null if detection fails or we're in a remote/headless environment.
+ */
+export declare function detectTerminalApp(): string | null;
 export default class OrchestratorAttach extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'new-tab': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        terminal: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'current-terminal': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        terminal: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private attachInCurrentTerminal;
     private openInNewTab;
 }

package/dist/commands/orchestrator/attach.js

@@ -9,23 +9,58 @@ import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadat
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+/**
+ * Detect the terminal emulator from environment variables.
+ * Returns a terminal app name suitable for AppleScript tab creation,
+ * or null if detection fails or we're in a remote/headless environment.
+ */
+export function detectTerminalApp() {
+    // Remote sessions should never attempt AppleScript/GUI operations
+    if (process.env.SSH_TTY || process.env.SSH_CONNECTION) {
+        return null;
+    }
+    // Headless / no display — skip GUI attempts
+    if (process.platform !== 'darwin' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return null;
+    }
+    const termProgram = process.env.TERM_PROGRAM;
+    if (!termProgram)
+        return null;
+    switch (termProgram) {
+        case 'iTerm.app':
+            return 'iTerm';
+        case 'ghostty':
+            return 'Ghostty';
+        case 'Apple_Terminal':
+            return 'Terminal';
+        case 'WezTerm':
+            return 'WezTerm';
+        default:
+            return null;
+    }
+}
 export default class OrchestratorAttach extends PromptCommand {
     static description = 'Attach to the running orchestrator tmux session';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --current-terminal',
+        '<%= config.bin %> <%= command.id %> --new-tab',
+        '<%= config.bin %> <%= command.id %> --new-tab --terminal Ghostty',
     ];
     static flags = {
         ...machineOutputFlags,
-        'current-terminal': Flags.boolean({
-            char: 'c',
-            description: 'Attach in current terminal instead of new tab',
+        'new-tab': Flags.boolean({
+            description: 'Open in a new terminal tab instead of attaching in the current terminal',
             default: false,
         }),
         terminal: Flags.string({
             char: 't',
-            description: 'Terminal app to use (iTerm, Terminal, Ghostty)',
-            default: 'iTerm',
+            description: 'Terminal app to use for new tab (iTerm, Terminal, Ghostty). Auto-detected if not specified.',
+        }),
+        'current-terminal': Flags.boolean({
+            char: 'c',
+            description: '[deprecated] Attach in current terminal (this is now the default behavior)',
+            hidden: true,
+            default: false,
         }),
     };
     async run() {
@@ -51,18 +86,37 @@ export default class OrchestratorAttach extends PromptCommand {
             }, createMetadata('orchestrator attach', flags));
             return;
         }
+        if (flags['current-terminal']) {
+            this.log(styles.warning('--current-terminal is deprecated. Direct tmux attach is now the default behavior.'));
+        }
+        if (flags.terminal && !flags['new-tab']) {
+            this.log(styles.warning('--terminal has no effect without --new-tab. Ignoring.'));
+        }
         this.log('');
         this.log(styles.info(`Attaching to orchestrator session: ${ORCHESTRATOR_SESSION_NAME}`));
-        if (flags['current-terminal']) {
-            try {
-                execSync(`tmux attach -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'inherit' });
-            }
-            catch {
-                this.error(`Failed to attach to orchestrator session "${ORCHESTRATOR_SESSION_NAME}"`);
+        if (flags['new-tab']) {
+            // Determine terminal app: explicit flag > auto-detect > error
+            const terminalApp = flags.terminal ?? detectTerminalApp();
+            if (!terminalApp) {
+                this.log(styles.warning('Could not detect terminal emulator for new tab.'));
+                this.log(styles.muted('Falling back to direct tmux attach in current terminal.'));
+                this.log(styles.muted('Tip: Use --terminal <app> to specify your terminal (iTerm, Terminal, Ghostty).'));
+                this.log('');
+                this.attachInCurrentTerminal();
+                return;
             }
+            await this.openInNewTab(terminalApp);
         }
         else {
-            await this.openInNewTab(flags.terminal);
+            this.attachInCurrentTerminal();
+        }
+    }
+    attachInCurrentTerminal() {
+        try {
+            execSync(`tmux attach -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'inherit' });
+        }
+        catch {
+            this.error(`Failed to attach to orchestrator session "${ORCHESTRATOR_SESSION_NAME}"`);
         }
     }
     async openInNewTab(terminalApp) {

package/dist/commands/orchestrator/index.js

@@ -1,5 +1,7 @@
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
+import { ORCHESTRATOR_SESSION_NAME } from './start.js';
 export default class Orchestrator extends PMOCommand {
     static description = 'Manage the orchestrator agent (start, attach, status, stop)';
     static examples = [
@@ -18,17 +20,30 @@ export default class Orchestrator extends PMOCommand {
     async execute() {
         const { flags } = await this.parse(Orchestrator);
         const jsonModeConfig = shouldOutputJson(flags) ? { flags, commandName: 'orchestrator' } : null;
+        // Check if orchestrator is currently running to offer contextual options
+        const hostSessions = getHostTmuxSessionNames();
+        const isRunning = hostSessions.includes(ORCHESTRATOR_SESSION_NAME);
+        // When running, show "Attach to running session" first since that's the likely intent
+        const choices = isRunning
+            ? [
+                { name: 'Attach to running session', value: 'attach', command: 'prlt orchestrator attach --json' },
+                { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
+                { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
+                { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
+                { name: 'Cancel', value: 'cancel' },
+            ]
+            : [
+                { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
+                { name: 'Attach to orchestrator', value: 'attach', command: 'prlt orchestrator attach --json' },
+                { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
+                { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
+                { name: 'Cancel', value: 'cancel' },
+            ];
         const { action } = await this.prompt([{
                 type: 'list',
                 name: 'action',
                 message: 'Orchestrator - What would you like to do?',
-                choices: [
-                    { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
-                    { name: 'Attach to orchestrator', value: 'attach', command: 'prlt orchestrator attach --json' },
-                    { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
-                    { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
-                    { name: 'Cancel', value: 'cancel' },
-                ],
+                choices,
             }], jsonModeConfig);
         if (action === 'cancel') {
             return;

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketLinkDuplicates extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticket: 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>;
+        machine: 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/ticket/link/duplicates.js

@@ -0,0 +1,95 @@
+import { Args } from '@oclif/core';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class TicketLinkDuplicates extends PMOCommand {
+    static description = 'Mark a ticket as a duplicate of another';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> TKT-001 --json',
+    ];
+    static args = {
+        ticket: Args.string({
+            description: 'Ticket that is a duplicate',
+            required: true,
+        }),
+        original: Args.string({
+            description: 'Original ticket (that this duplicates)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketLinkDuplicates);
+        const jsonMode = shouldOutputJson(flags);
+        const projectId = await this.requireProject();
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('ticket link duplicates', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Verify the source ticket exists
+        const ticket = await this.storage.getTicket(args.ticket);
+        if (!ticket) {
+            return handleError('TICKET_NOT_FOUND', `Ticket not found: ${args.ticket}`);
+        }
+        // If original ticket not provided, prompt for selection
+        if (!args.original) {
+            const tickets = await this.storage.listTickets(projectId);
+            const otherTickets = tickets.filter(t => t.id !== args.ticket);
+            if (otherTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No other tickets to select as original.');
+            }
+            const projectFlag = flags.project ? ` -P ${flags.project}` : '';
+            const choices = otherTickets.map(t => ({
+                name: `${t.id} - ${t.title}`,
+                value: t.id,
+                command: `prlt ticket link duplicates ${args.ticket} ${t.id}${projectFlag} --json`,
+            }));
+            const message = `Select the original ticket that ${args.ticket} duplicates:`;
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'original', message, choices), createMetadata('ticket link duplicates', flags));
+                return;
+            }
+            const { selected } = await this.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message,
+                    choices,
+                }], null);
+            args.original = selected;
+        }
+        // Verify original ticket exists
+        const originalTicket = await this.storage.getTicket(args.original);
+        if (!originalTicket) {
+            return handleError('ORIGINAL_NOT_FOUND', `Original ticket not found: ${args.original}`);
+        }
+        // Create the duplicates dependency
+        try {
+            await this.storage.createTicketDependency(args.ticket, args.original, 'duplicates');
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    ticketId: args.ticket,
+                    originalTicketId: args.original,
+                    type: 'duplicates',
+                }, createMetadata('ticket link duplicates', flags));
+                return;
+            }
+            this.log(styles.success(`\n${args.ticket} marked as duplicate of ${args.original}`));
+            this.log(styles.muted(`  ${ticket.title}`));
+            this.log(styles.muted(`  duplicates: ${originalTicket.title}`));
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('already exists')) {
+                return handleError('ALREADY_EXISTS', 'Duplicates dependency already exists.');
+            }
+            throw error;
+        }
+    }
+}

package/dist/commands/ticket/link/index.js

@@ -55,6 +55,8 @@ export default class TicketLink extends PMOCommand {
         const projectFlag = flags.project ? ` -P ${flags.project}` : '';
         const menuChoices = [
             { name: 'Add blocker', value: 'block', command: `prlt ticket link block ${args.ticket}${projectFlag} --json` },
+            { name: 'Add related ticket', value: 'relates', command: `prlt ticket link relates ${args.ticket}${projectFlag} --json` },
+            { name: 'Mark as duplicate', value: 'duplicates', command: `prlt ticket link duplicates ${args.ticket}${projectFlag} --json` },
             { name: 'View links', value: 'view', command: `prlt link list ${args.ticket}${projectFlag} --json` },
             { name: 'Remove link', value: 'remove', command: `prlt link remove ${args.ticket}${projectFlag} --json` },
             { name: 'Cancel', value: 'cancel', command: '' },
@@ -81,6 +83,18 @@ export default class TicketLink extends PMOCommand {
                 await cmd.run();
                 break;
             }
+            case 'relates': {
+                const { default: RelatesCommand } = await import('./relates.js');
+                const cmd = new RelatesCommand([args.ticket, ...(flags.project ? ['-P', flags.project] : [])], this.config);
+                await cmd.run();
+                break;
+            }
+            case 'duplicates': {
+                const { default: DuplicatesCommand } = await import('./duplicates.js');
+                const cmd = new DuplicatesCommand([args.ticket, ...(flags.project ? ['-P', flags.project] : [])], this.config);
+                await cmd.run();
+                break;
+            }
             case 'view': {
                 const { default: LinkListCommand } = await import('../../link/list.js');
                 const cmd = new LinkListCommand([args.ticket, ...(flags.project ? ['-P', flags.project] : [])], this.config);