@proletariat/cli 0.3.45 → 0.3.47

package/dist/commands/orchestrator/start.js

@@ -11,8 +11,26 @@ import { DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
 import { runExecution } from '../../lib/execution/runners.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
-import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, } from '../../lib/execution/config.js';
-export const ORCHESTRATOR_SESSION_NAME = 'prlt-orchestrator-main';
+import { loadExecutionConfig, getTerminalApp, getShell, detectShell, detectTerminalApp, } from '../../lib/execution/config.js';
+/**
+ * Build orchestrator tmux session name.
+ * Default: 'prlt-orchestrator-main'
+ * With --name: 'prlt-orchestrator-{name}'
+ */
+export function buildOrchestratorSessionName(name = 'main') {
+    const safeName = name
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return `prlt-orchestrator-${safeName || 'main'}`;
+}
+/**
+ * Find running orchestrator session(s) by prefix match.
+ * Returns all tmux session names that start with 'prlt-orchestrator-'.
+ */
+export function findRunningOrchestratorSessions(hostSessions) {
+    return hostSessions.filter(s => s.startsWith('prlt-orchestrator-'));
+}
 export default class OrchestratorStart extends PromptCommand {
     static description = 'Start the orchestrator agent in a tmux session';
     static examples = [
@@ -47,36 +65,50 @@ export default class OrchestratorStart extends PromptCommand {
             default: false,
             exclusive: ['skip-permissions'],
         }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Name for the orchestrator session (default: main)',
+        }),
         background: Flags.boolean({
             char: 'b',
             description: 'Start detached (don\'t open terminal tab)',
             default: false,
+            exclusive: ['foreground'],
+        }),
+        foreground: Flags.boolean({
+            char: 'f',
+            description: 'Attach to the tmux session in the current terminal (blocking)',
+            default: false,
+            exclusive: ['background'],
         }),
     };
     async run() {
         const { flags } = await this.parse(OrchestratorStart);
         const jsonMode = shouldOutputJson(flags);
+        const orchestratorName = flags.name || 'main';
+        const sessionName = buildOrchestratorSessionName(orchestratorName);
         // Check if orchestrator is already running
         const hostSessions = getHostTmuxSessionNames();
-        if (hostSessions.includes(ORCHESTRATOR_SESSION_NAME)) {
+        if (hostSessions.includes(sessionName)) {
             if (jsonMode) {
-                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${ORCHESTRATOR_SESSION_NAME}). Use "prlt orchestrator attach" to reattach.`, createMetadata('orchestrator start', flags));
+                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${sessionName}). Use "prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}" to reattach.`, createMetadata('orchestrator start', flags));
                 return;
             }
             this.log('');
-            this.log(styles.warning(`Orchestrator is already running (session: ${ORCHESTRATOR_SESSION_NAME})`));
+            this.log(styles.warning(`Orchestrator is already running (session: ${sessionName})`));
             this.log('');
+            const attachArgs = flags.name ? ['--name', flags.name] : [];
             const { choice } = await this.prompt([{
                     type: 'list',
                     name: 'choice',
                     message: 'What would you like to do?',
                     choices: [
-                        { name: 'Attach to running orchestrator', value: 'attach', command: 'prlt orchestrator attach --json' },
+                        { name: 'Attach to running orchestrator', value: 'attach', command: `prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''} --json` },
                         { name: 'Cancel', value: 'cancel' },
                     ],
                 }], jsonMode ? { flags, commandName: 'orchestrator start' } : null);
             if (choice === 'attach') {
-                await this.config.runCommand('orchestrator:attach', []);
+                await this.config.runCommand('orchestrator:attach', attachArgs);
             }
             return;
         }
@@ -169,12 +201,12 @@ export default class OrchestratorStart extends PromptCommand {
             }
         }
         // Build execution context
-        // Use ticketId='prlt', actionName='orchestrator', agentName='main'
-        // so buildSessionName produces 'prlt-orchestrator-main'
+        // Use ticketId='prlt', actionName='orchestrator', agentName=orchestratorName
+        // so buildSessionName produces 'prlt-orchestrator-{name}'
         const context = {
             ticketId: 'prlt',
             ticketTitle: 'Orchestrator',
-            agentName: 'main',
+            agentName: orchestratorName,
             agentDir: hqPath,
             worktreePath: hqPath,
             branch: 'main',
@@ -202,19 +234,54 @@ export default class OrchestratorStart extends PromptCommand {
         catch {
             // Ignore config loading errors, use defaults
         }
-        // If no terminal preference saved, prompt for it (first run only)
-        if (!jsonMode && db) {
-            if (!hasTerminalPreference(db)) {
-                executionConfig.terminal.app = await promptTerminalPreference(db);
+        // Auto-detect shell (never prompt for orchestrator)
+        if (db) {
+            executionConfig.shell = await getShell(db);
+        }
+        else {
+            executionConfig.shell = detectShell() || 'zsh';
+        }
+        // Determine display mode
+        let displayMode;
+        if (flags.background) {
+            displayMode = 'background';
+        }
+        else if (flags.foreground) {
+            displayMode = 'foreground';
+        }
+        else {
+            const displayChoices = [
+                { name: 'New terminal tab — opens attached to the tmux session', value: 'terminal', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --json` },
+                { name: 'Current session — attach to tmux here (foreground, blocking)', value: 'foreground', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --foreground --json` },
+                { name: 'Background — start detached, attach later', value: 'background', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --background --json` },
+            ];
+            const displayMessage = 'How do you want to view the orchestrator?';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'displayMode', displayMessage, displayChoices), createMetadata('orchestrator start', flags));
+                return;
             }
-            else {
+            const { displayMode: selectedMode } = await this.prompt([{
+                    type: 'list',
+                    name: 'displayMode',
+                    message: displayMessage,
+                    choices: displayChoices,
+                }], jsonMode ? { flags, commandName: 'orchestrator start' } : null);
+            displayMode = selectedMode;
+        }
+        // For 'terminal' display mode, auto-detect terminal app
+        if (displayMode === 'terminal') {
+            if (db) {
                 executionConfig.terminal.app = await getTerminalApp(db);
             }
-            if (!hasShellPreference(db)) {
-                executionConfig.shell = await promptShellPreference(db);
-            }
             else {
-                executionConfig.shell = await getShell(db);
+                const detected = detectTerminalApp();
+                if (detected) {
+                    executionConfig.terminal.app = detected;
+                }
+                else {
+                    // Can't detect terminal and no db to prompt — fall back to foreground
+                    displayMode = 'foreground';
+                }
             }
         }
         // Show what we're doing
@@ -223,14 +290,17 @@ export default class OrchestratorStart extends PromptCommand {
             this.log(styles.muted(`   Starting orchestrator...`));
             this.log(styles.muted(`   Executor: ${selectedExecutor}`));
             this.log(styles.muted(`   Permission mode: ${sandboxed ? 'sandboxed' : 'skip-permissions'}`));
+            this.log(styles.muted(`   Display mode: ${displayMode}`));
             this.log(styles.muted(`   Directory: ${hqPath}`));
+            if (orchestratorName !== 'main') {
+                this.log(styles.muted(`   Name: ${orchestratorName}`));
+            }
             if (actionPrompt) {
                 this.log(styles.muted(`   Prompt: "${actionPrompt.substring(0, 60)}${actionPrompt.length > 60 ? '...' : ''}"`));
             }
             this.log('');
         }
         // Launch orchestrator
-        const displayMode = flags.background ? 'background' : 'terminal';
         const result = await runExecution('host', context, selectedExecutor, executionConfig, {
             displayMode,
         });
@@ -246,7 +316,7 @@ export default class OrchestratorStart extends PromptCommand {
                         environment: 'host',
                         displayMode,
                         sandboxed,
-                        sessionId: result.sessionId || ORCHESTRATOR_SESSION_NAME,
+                        sessionId: result.sessionId || sessionName,
                     });
                 }
                 catch {
@@ -255,17 +325,18 @@ export default class OrchestratorStart extends PromptCommand {
             }
             if (jsonMode) {
                 outputSuccessAsJson({
-                    sessionId: result.sessionId || ORCHESTRATOR_SESSION_NAME,
+                    sessionId: result.sessionId || sessionName,
                     executor: selectedExecutor,
                     sandboxed,
                     displayMode,
                     directory: hqPath,
+                    name: orchestratorName,
                 }, createMetadata('orchestrator start', flags));
             }
-            if (flags.background) {
+            if (displayMode === 'background') {
                 this.log(styles.success(`Orchestrator started in background`));
-                this.log(styles.muted(`   Session: ${result.sessionId || ORCHESTRATOR_SESSION_NAME}`));
-                this.log(styles.muted(`   Attach with: prlt orchestrator attach`));
+                this.log(styles.muted(`   Session: ${result.sessionId || sessionName}`));
+                this.log(styles.muted(`   Attach with: prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}`));
             }
             else {
                 this.log(styles.success(`Orchestrator started`));

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

@@ -3,6 +3,7 @@ export default class OrchestratorStatus extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         peek: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         lines: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/orchestrator/status.js

@@ -4,7 +4,7 @@ import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames, captureTmuxPane } from '../../lib/execution/session-utils.js';
-import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { buildOrchestratorSessionName } from './start.js';
 export default class OrchestratorStatus extends PromptCommand {
     static description = 'Check if the orchestrator is running';
     static examples = [
@@ -14,6 +14,10 @@ export default class OrchestratorStatus extends PromptCommand {
     ];
     static flags = {
         ...machineOutputFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the orchestrator session to check (default: main)',
+        }),
         peek: Flags.boolean({
             description: 'Show recent output from the orchestrator',
             default: false,
@@ -26,16 +30,17 @@ export default class OrchestratorStatus extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStatus);
         const jsonMode = shouldOutputJson(flags);
+        const sessionName = buildOrchestratorSessionName(flags.name || 'main');
         const hostSessions = getHostTmuxSessionNames();
-        const isRunning = hostSessions.includes(ORCHESTRATOR_SESSION_NAME);
+        const isRunning = hostSessions.includes(sessionName);
         let recentOutput = null;
         if (isRunning && flags.peek) {
-            recentOutput = captureTmuxPane(ORCHESTRATOR_SESSION_NAME, flags.lines);
+            recentOutput = captureTmuxPane(sessionName, flags.lines);
         }
         if (jsonMode) {
             outputSuccessAsJson({
                 running: isRunning,
-                sessionId: isRunning ? ORCHESTRATOR_SESSION_NAME : null,
+                sessionId: isRunning ? sessionName : null,
                 ...(recentOutput !== null && { recentOutput }),
             }, createMetadata('orchestrator status', flags));
             return;
@@ -43,7 +48,7 @@ export default class OrchestratorStatus extends PromptCommand {
         this.log('');
         if (isRunning) {
             this.log(styles.success(`Orchestrator is running`));
-            this.log(styles.muted(`   Session: ${ORCHESTRATOR_SESSION_NAME}`));
+            this.log(styles.muted(`   Session: ${sessionName}`));
             this.log(styles.muted(`   Attach: prlt orchestrator attach`));
             this.log(styles.muted(`   Poke:   prlt session poke orchestrator "message"`));
             if (recentOutput) {

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

@@ -3,6 +3,7 @@ export default class OrchestratorStop extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/orchestrator/stop.js

@@ -10,7 +10,7 @@ import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadat
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
-import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { buildOrchestratorSessionName } from './start.js';
 export default class OrchestratorStop extends PromptCommand {
     static description = 'Stop the running orchestrator';
     static examples = [
@@ -19,6 +19,10 @@ export default class OrchestratorStop extends PromptCommand {
     ];
     static flags = {
         ...machineOutputFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the orchestrator session to stop (default: main)',
+        }),
         force: Flags.boolean({
             char: 'f',
             description: 'Skip confirmation',
@@ -28,9 +32,10 @@ export default class OrchestratorStop extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStop);
         const jsonMode = shouldOutputJson(flags);
+        const sessionName = buildOrchestratorSessionName(flags.name || 'main');
         // Check if orchestrator session exists
         const hostSessions = getHostTmuxSessionNames();
-        if (!hostSessions.includes(ORCHESTRATOR_SESSION_NAME)) {
+        if (!hostSessions.includes(sessionName)) {
             if (jsonMode) {
                 outputErrorAsJson('NOT_RUNNING', 'Orchestrator is not running.', createMetadata('orchestrator stop', flags));
                 return;
@@ -58,7 +63,7 @@ export default class OrchestratorStop extends PromptCommand {
         }
         // Kill the tmux session
         try {
-            execSync(`tmux kill-session -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'pipe' });
+            execSync(`tmux kill-session -t "${sessionName}"`, { stdio: 'pipe' });
         }
         catch (error) {
             if (jsonMode) {
@@ -92,7 +97,7 @@ export default class OrchestratorStop extends PromptCommand {
         }
         if (jsonMode) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'stopped',
             }, createMetadata('orchestrator stop', flags));
             return;

package/dist/commands/session/attach.js

@@ -6,7 +6,8 @@ import * as os from 'node:os';
 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 { ExecutionStorage, loadExecutionConfig, shouldUseControlMode, buildTmuxAttachCommand } from '../../lib/execution/index.js';
+import { detectTerminalApp } from '../orchestrator/attach.js';
 import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findContainerSessionsByPrefix, findSessionForExecution, } from '../../lib/execution/session-utils.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
@@ -106,12 +107,32 @@ export default class SessionAttach extends PMOCommand {
         // Attach to the session
         this.log('');
         this.log(styles.info(`Attaching to session: ${selectedSession.sessionId}`));
+        // Determine if we should use tmux control mode (-u -CC) for iTerm
+        let useControlMode = false;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            const db = new Database(dbPath);
+            try {
+                const config = loadExecutionConfig(db);
+                const termApp = detectTerminalApp();
+                if (termApp === 'iTerm') {
+                    useControlMode = shouldUseControlMode('iTerm', config.tmux.controlMode);
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Not in a workspace or DB not available - fall back to no control mode
+        }
         // Default to new tab unless --current-terminal is specified
         if (flags['current-terminal']) {
-            await this.attachInCurrentTerminal(selectedSession);
+            await this.attachInCurrentTerminal(selectedSession, useControlMode);
         }
         else {
-            await this.attachInNewTab(selectedSession, flags.terminal);
+            await this.attachInNewTab(selectedSession, flags.terminal, useControlMode);
         }
     }
     /**
@@ -247,13 +268,14 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Attach to session in current terminal
      */
-    async attachInCurrentTerminal(session) {
+    async attachInCurrentTerminal(session, useControlMode) {
         try {
+            const tmuxAttach = buildTmuxAttachCommand(useControlMode, session.type === 'container');
             if (session.type === 'container' && session.containerId) {
-                execSync(`docker exec -it ${session.containerId} tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+                execSync(`docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`, { stdio: 'inherit' });
             }
             else {
-                execSync(`tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+                execSync(`${tmuxAttach} -t "${session.sessionId}"`, { stdio: 'inherit' });
             }
         }
         catch {
@@ -263,7 +285,7 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Attach to session in a new terminal tab
      */
-    async attachInNewTab(session, terminalApp) {
+    async attachInNewTab(session, terminalApp, useControlMode) {
         // Build a readable title for the tab
         const title = `${session.ticketId} (${session.agentName})`;
         // Create a script that sets tab title and attaches to tmux
@@ -271,9 +293,10 @@ export default class SessionAttach extends PMOCommand {
         fs.mkdirSync(baseDir, { recursive: true });
         const scriptPath = path.join(baseDir, `attach-${Date.now()}.sh`);
         // Different attach command for container vs host sessions
+        const tmuxAttach = buildTmuxAttachCommand(useControlMode, session.type === 'container');
         const attachCmd = session.type === 'container' && session.containerId
-            ? `docker exec -it ${session.containerId} tmux -u attach -t "${session.sessionId}"`
-            : `tmux attach -t "${session.sessionId}"`;
+            ? `docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`
+            : `${tmuxAttach} -t "${session.sessionId}"`;
         const script = `#!/bin/bash
 # Set terminal tab title
 echo -ne "\\033]0;${title}\\007"

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);

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketLinkRelates extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticket: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        related: 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>;
+}