@proletariat/cli 0.3.51 → 0.3.52

package/dist/commands/session/list.js

@@ -47,6 +47,8 @@ export default class SessionList extends PMOCommand {
             const runningExecutions = executionStorage?.listExecutions({ status: 'running' }) || [];
             const startingExecutions = executionStorage?.listExecutions({ status: 'starting' }) || [];
             const activeExecutions = [...runningExecutions, ...startingExecutions];
+            // Refresh execution state so dead sessions aren't reported as running.
+            executionStorage?.cleanupStaleExecutions();
             // Get list of actual tmux sessions for verification
             const hostTmuxSessions = getHostTmuxSessionNames();
             const containerTmuxSessions = getContainerTmuxSessionMap();
@@ -105,15 +107,14 @@ export default class SessionList extends PMOCommand {
                         matchedHostSessions.add(actualSessionId);
                     }
                 }
-                // Always include sessions from DB that have a sessionId.
-                // When tmux verification fails (e.g., Docker/tmux not accessible from MCP context),
-                // show the session with the DB status instead of silently dropping it.
-                if (actualSessionId) {
+                // Only include active sessions by default.
+                // Use --all to include stale DB records (exists=false).
+                if (actualSessionId && (exists || flags.all)) {
                     sessions.push({
                         sessionId: actualSessionId,
                         ticketId: exec.ticketId,
                         agentName: exec.agentName,
-                        status: exists ? exec.status : (flags.all ? 'stale' : exec.status),
+                        status: exists ? exec.status : 'stale',
                         environment: isContainer ? 'container' : 'host',
                         containerId,
                         exists,

package/dist/commands/work/index.js

@@ -25,6 +25,8 @@ export default class Work extends PMOCommand {
             { id: 'status', name: 'View work status (in-progress tickets)', command: `prlt work status -P ${projectId} --json` },
             { id: 'start', name: 'Start work (launch single agent)', command: `prlt work start -P ${projectId} --json` },
             { id: 'linear', name: 'Spawn from Linear issue', command: `prlt work linear -P ${projectId} --json` },
+            { id: 'jira', name: 'Spawn from Jira issue', command: `prlt work jira -P ${projectId} --json` },
+            { id: 'source', name: 'Set active work source defaults', command: `prlt work source -P ${projectId} --json` },
             { id: 'resolve', name: 'Resolve questions (agent-assisted)', command: `prlt work resolve -P ${projectId} --json` },
             { id: 'spawn', name: 'Spawn work (batch by column)', command: `prlt work spawn -P ${projectId} --json` },
             { id: 'watch', name: 'Watch column (auto-spawn)', command: `prlt work watch -P ${projectId} --json` },
@@ -58,6 +60,11 @@ export default class Work extends PMOCommand {
             case 'linear':
                 await this.config.runCommand('work:linear', projectArgs);
                 break;
+            case 'jira':
+                await this.config.runCommand('work:jira', projectArgs);
+            case 'source':
+                await this.config.runCommand('work:source', projectArgs);
+                break;
             case 'resolve':
                 await this.config.runCommand('work:resolve', projectArgs);
                 break;

package/dist/commands/work/jira.d.ts

@@ -0,0 +1,28 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkJira extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        host: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        email: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        jql: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        issue: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        executor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        display: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        action: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'run-on-host': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'create-pr': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: 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>;
+    };
+    private findLinkedTicket;
+    private createOrUpdateLinkedTicket;
+    execute(): Promise<void>;
+}

package/dist/commands/work/jira.js

@@ -0,0 +1,225 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard, } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+import { ExternalIssueAdapterError, } from '../../lib/external-issues/types.js';
+import { listJiraIssues, getJiraIssueByKey, buildJiraIssueChoiceCommand, buildJiraTicketDescription, buildJiraMetadata, buildJiraSpawnContextMessage, } from '../../lib/external-issues/jira.js';
+function buildWorkStartArgs(options) {
+    const args = [options.ticketId, '--project', options.projectId, '--ephemeral'];
+    if (options.executor)
+        args.push('--executor', options.executor);
+    if (options.display)
+        args.push('--display', options.display);
+    if (options.runOnHost)
+        args.push('--run-on-host');
+    if (options.skipPermissions)
+        args.push('--skip-permissions');
+    if (options.createPr)
+        args.push('--create-pr');
+    if (options.action)
+        args.push('--action', options.action);
+    if (options.message)
+        args.push('--message', options.message);
+    if (options.json)
+        args.push('--json');
+    if (options.machine)
+        args.push('--machine');
+    if (options.yes)
+        args.push('--yes');
+    return args;
+}
+export default class WorkJira extends PMOCommand {
+    static description = 'List/select Jira issues and spawn work using the existing work-start flow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --host https://myorg.atlassian.net --project-key PROJ',
+        '<%= config.bin %> <%= command.id %> --host https://myorg.atlassian.net --issue PROJ-123',
+        '<%= config.bin %> <%= command.id %> --host https://myorg.atlassian.net --issue PROJ-123 --yes --skip-permissions --display terminal',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        host: Flags.string({
+            description: 'Jira host URL (fallback: PRLT_JIRA_HOST or JIRA_HOST)',
+        }),
+        email: Flags.string({
+            description: 'Jira account email (fallback: PRLT_JIRA_EMAIL or JIRA_EMAIL)',
+        }),
+        token: Flags.string({
+            description: 'Jira API token (fallback: PRLT_JIRA_API_TOKEN or JIRA_API_TOKEN)',
+        }),
+        'project-key': Flags.string({
+            description: 'Jira project key for listing issues (fallback: PRLT_JIRA_PROJECT or JIRA_PROJECT_KEY)',
+        }),
+        jql: Flags.string({
+            description: 'Custom JQL for listing issues (overrides project key filters)',
+        }),
+        issue: Flags.string({
+            description: 'Jira issue key (for example: PROJ-123)',
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of Jira issues to fetch',
+            default: 20,
+            min: 1,
+            max: 100,
+        }),
+        executor: Flags.string({
+            char: 'e',
+            description: 'Override executor',
+            options: ['claude-code', 'codex', 'aider', 'custom'],
+        }),
+        display: Flags.string({
+            char: 'd',
+            description: 'Display mode',
+            options: ['terminal', 'background', 'foreground'],
+        }),
+        action: Flags.string({
+            char: 'A',
+            description: 'Action to run in work start (default: implement)',
+            default: 'implement',
+        }),
+        message: Flags.string({
+            description: 'Additional instructions appended to spawn context',
+        }),
+        'run-on-host': Flags.boolean({
+            description: 'Run on host even if devcontainer exists',
+            default: false,
+        }),
+        'skip-permissions': Flags.boolean({
+            description: 'Skip permission prompts (danger mode)',
+            default: false,
+        }),
+        'create-pr': Flags.boolean({
+            description: 'Create PR when work is ready',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts in downstream work start',
+            default: false,
+        }),
+    };
+    async findLinkedTicket(projectId, envelope) {
+        const tickets = await this.storage.listTickets(projectId);
+        return tickets.find((ticket) => {
+            const source = ticket.metadata?.external_source;
+            const key = ticket.metadata?.external_key;
+            const id = ticket.metadata?.external_id;
+            return source === 'jira'
+                && (key === envelope.source.externalKey || id === envelope.source.externalId);
+        });
+    }
+    async createOrUpdateLinkedTicket(projectId, envelope) {
+        const existing = await this.findLinkedTicket(projectId, envelope);
+        const description = buildJiraTicketDescription(envelope);
+        const metadata = buildJiraMetadata(envelope);
+        if (existing) {
+            const updated = await this.storage.updateTicket(existing.id, {
+                title: envelope.title,
+                description,
+                priority: envelope.priority ?? undefined,
+                category: envelope.category ?? undefined,
+                labels: envelope.labels,
+                metadata: {
+                    ...existing.metadata,
+                    ...metadata,
+                },
+            });
+            return updated;
+        }
+        return this.storage.createTicket(projectId, {
+            title: envelope.title,
+            description,
+            priority: envelope.priority ?? undefined,
+            category: envelope.category ?? undefined,
+            labels: envelope.labels,
+            metadata,
+        });
+    }
+    async execute() {
+        const { flags } = await this.parse(WorkJira);
+        const jsonMode = shouldOutputJson(flags);
+        const projectId = await this.requireProject({
+            jsonMode: {
+                flags,
+                commandName: 'work jira',
+                baseCommand: 'prlt work jira',
+            },
+        });
+        const config = {
+            host: flags.host,
+            email: flags.email,
+            apiToken: flags.token,
+            projectKey: flags['project-key'],
+            jql: flags.jql,
+        };
+        let issues;
+        try {
+            issues = await listJiraIssues(config, {
+                limit: flags.limit,
+            });
+        }
+        catch (error) {
+            if (error instanceof ExternalIssueAdapterError) {
+                return this.handleError(error.code, error.message, { jsonMode, commandName: 'work jira', flags });
+            }
+            const msg = error instanceof Error ? error.message : 'Failed to fetch Jira issues.';
+            return this.handleError('JIRA_REQUEST_FAILED', msg, { jsonMode, commandName: 'work jira', flags });
+        }
+        if (issues.length === 0) {
+            return this.handleError('NO_JIRA_ISSUES', 'No matching Jira issues found for the configured query.', { jsonMode, commandName: 'work jira', flags });
+        }
+        let selectedIssue = issues.find(issue => issue.source.externalKey === flags.issue?.toUpperCase());
+        if (!selectedIssue && flags.issue) {
+            try {
+                selectedIssue = await getJiraIssueByKey(config, flags.issue) ?? undefined;
+            }
+            catch (error) {
+                if (error instanceof ExternalIssueAdapterError) {
+                    return this.handleError(error.code, error.message, { jsonMode, commandName: 'work jira', flags });
+                }
+                const msg = error instanceof Error ? error.message : 'Failed to fetch Jira issue.';
+                return this.handleError('JIRA_REQUEST_FAILED', msg, { jsonMode, commandName: 'work jira', flags });
+            }
+            if (!selectedIssue) {
+                return this.handleError('JIRA_ISSUE_NOT_FOUND', `Jira issue "${flags.issue}" was not found.`, { jsonMode, commandName: 'work jira', flags });
+            }
+        }
+        if (!selectedIssue) {
+            const selectedKey = await this.selectFromList({
+                message: 'Select Jira issue to spawn:',
+                items: issues,
+                getName: (issue) => {
+                    const priority = issue.priority || 'None';
+                    return `[${priority}] ${issue.source.externalKey} - ${issue.title}`;
+                },
+                getValue: issue => issue.source.externalKey,
+                getCommand: issue => buildJiraIssueChoiceCommand(issue.source.externalKey, projectId),
+                jsonMode: jsonMode ? { flags, commandName: 'work jira' } : null,
+            });
+            if (!selectedKey) {
+                return;
+            }
+            selectedIssue = issues.find(issue => issue.source.externalKey === selectedKey);
+            if (!selectedIssue) {
+                return this.handleError('JIRA_ISSUE_NOT_FOUND', `Jira issue "${selectedKey}" was not found.`, { jsonMode, commandName: 'work jira', flags });
+            }
+        }
+        const ticket = await this.createOrUpdateLinkedTicket(projectId, selectedIssue);
+        await autoExportToBoard(this.pmoPath, this.storage);
+        const contextMessage = buildJiraSpawnContextMessage(selectedIssue, flags.message);
+        const args = buildWorkStartArgs({
+            ticketId: ticket.id,
+            projectId,
+            executor: flags.executor,
+            display: flags.display,
+            runOnHost: flags['run-on-host'],
+            skipPermissions: flags['skip-permissions'],
+            createPr: flags['create-pr'],
+            action: flags.action,
+            message: contextMessage,
+            json: flags.json,
+            machine: flags.machine,
+            yes: flags.yes,
+        });
+        await this.config.runCommand('work:start', args);
+    }
+}

package/dist/commands/work/source/set.d.ts

@@ -0,0 +1,12 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class WorkSourceSet extends PMOCommand {
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    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/work/source/set.js

@@ -0,0 +1,52 @@
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, } from '../../../lib/prompt-json.js';
+import { parseWorkSourceRef, formatWorkSourceRef, saveActiveWorkSource, } from '../../../lib/work-source/index.js';
+export default class WorkSourceSet extends PMOCommand {
+    static description = 'Set the active work source used by "work spawn"';
+    static strict = false;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> pmo',
+        '<%= config.bin %> <%= command.id %> linear:PRO',
+        '<%= config.bin %> <%= command.id %> jira:ABC',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { flags, argv } = await this.parse(WorkSourceSet);
+        const jsonMode = shouldOutputJson(flags);
+        const sourceInput = argv[0]?.trim();
+        if (!sourceInput) {
+            const message = 'Usage: prlt work source set <provider[:context]>';
+            if (jsonMode) {
+                outputErrorAsJson('SOURCE_REQUIRED', message, createMetadata('work source set', flags));
+            }
+            this.error(message);
+        }
+        let source;
+        try {
+            source = parseWorkSourceRef(sourceInput);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Invalid work source.';
+            if (jsonMode) {
+                outputErrorAsJson('INVALID_SOURCE', message, createMetadata('work source set', flags));
+            }
+            this.error(message);
+        }
+        const db = this.storage.getDatabase();
+        saveActiveWorkSource(db, source);
+        const ref = formatWorkSourceRef(source);
+        if (jsonMode) {
+            outputSuccessAsJson({
+                activeSource: {
+                    provider: source.provider,
+                    context: source.context ?? null,
+                    ref,
+                },
+            }, createMetadata('work source set', flags));
+        }
+        this.log(styles.success(`Active work source set to ${ref}`));
+    }
+}

package/dist/commands/work/source.d.ts

@@ -0,0 +1,11 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkSource extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    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/work/source.js

@@ -0,0 +1,53 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { loadActiveWorkSource, getRegisteredWorkSources, formatWorkSourceRef, } from '../../lib/work-source/index.js';
+export default class WorkSource extends PMOCommand {
+    static description = 'Show the active work source used by "work spawn"';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> work source set linear:PRO',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { flags } = await this.parse(WorkSource);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        const active = loadActiveWorkSource(db);
+        const registered = getRegisteredWorkSources(db);
+        const activeResult = active ? {
+            provider: active.provider,
+            context: active.context ?? null,
+            ref: formatWorkSourceRef(active),
+        } : null;
+        const registeredResult = registered.map((source) => ({
+            provider: source.provider,
+            context: source.context ?? null,
+            ref: formatWorkSourceRef(source),
+        }));
+        if (jsonMode) {
+            outputSuccessAsJson({
+                activeSource: activeResult,
+                registeredSources: registeredResult,
+            }, createMetadata('work source', flags));
+        }
+        this.log(styles.header('Work Source'));
+        if (active) {
+            this.log(styles.success(`  Active: ${formatWorkSourceRef(active)}`));
+            this.log(styles.muted(`  Provider: ${active.provider}`));
+            if (active.context) {
+                this.log(styles.muted(`  Context: ${active.context}`));
+            }
+        }
+        else {
+            this.log(styles.muted('  Active: not set'));
+            this.log(styles.muted('  Default behavior: PMO tickets unless an external source is selected'));
+        }
+        this.log('');
+        this.log(styles.muted(`Registered sources: ${registeredResult.map(source => source.ref).join(', ')}`));
+        this.log(styles.muted('Set with: prlt work source set <provider[:context]>'));
+    }
+}

package/dist/commands/work/spawn.d.ts

@@ -32,6 +32,7 @@ export default class WorkSpawn extends PMOCommand {
         epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'from-linear': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'linear-team': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'linear-state': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'linear-label': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/work/spawn.js

@@ -10,6 +10,7 @@ import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadat
 import { FlagResolver } from '../../lib/flags/index.js';
 import { loadDietConfig, formatDietConfig, } from '../../lib/pmo/diet.js';
 import { LinearClient, LinearMapper, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+import { parseWorkSourceRef, formatWorkSourceRef, loadActiveWorkSource, saveActiveWorkSource, getRegisteredWorkSources, } from '../../lib/work-source/index.js';
 export default class WorkSpawn extends PMOCommand {
     static description = 'Spawn work for multiple tickets by column (batch mode)';
     static strict = false; // Allow multiple ticket ID args without defining them
@@ -28,6 +29,8 @@ export default class WorkSpawn extends PMOCommand {
         '<%= config.bin %> <%= command.id %> --count 5 --priority P0 --action implement  # Filtered by priority',
         '<%= config.bin %> <%= command.id %> --from-linear                      # Pull Linear issues → PMO → spawn',
         '<%= config.bin %> <%= command.id %> --from-linear ENG-123 ENG-124      # Pull specific Linear issues → spawn',
+        '<%= config.bin %> <%= command.id %> --from linear:ENG                  # Use source override (provider[:context])',
+        '<%= config.bin %> work source set linear:ENG                           # Persist default source for future spawn',
         '<%= config.bin %> <%= command.id %> --from-linear --linear-team ENG    # Pull from specific team',
         '<%= config.bin %> <%= command.id %> --from-linear --linear-state "In Progress"  # Filter by state',
         '<%= config.bin %> <%= command.id %> --count 10 --diet --category ship,grow --action groom  # Combined',
@@ -152,22 +155,21 @@ export default class WorkSpawn extends PMOCommand {
             description: 'Pull issues from Linear, mirror into PMO, then spawn agents',
             default: false,
         }),
+        from: Flags.string({
+            description: 'Source override in provider[:context] format (e.g., pmo, linear:PRO)',
+        }),
         'linear-team': Flags.string({
             description: 'Linear team key to pull issues from (e.g., ENG)',
-            dependsOn: ['from-linear'],
         }),
         'linear-state': Flags.string({
             description: 'Filter Linear issues by state name (e.g., "In Progress")',
-            dependsOn: ['from-linear'],
         }),
         'linear-label': Flags.string({
             description: 'Filter Linear issues by label name',
-            dependsOn: ['from-linear'],
         }),
         'linear-limit': Flags.integer({
             description: 'Maximum number of Linear issues to pull',
             default: 20,
-            dependsOn: ['from-linear'],
         }),
     };
     async execute() {
@@ -192,10 +194,70 @@ export default class WorkSpawn extends PMOCommand {
         }
         // Parse ticket IDs from args (everything after flags)
         let ticketIdArgs = argv;
+        // Resolve source precedence:
+        // 1) --from override (new canonical behavior)
+        // 2) --from-linear (legacy compatibility)
+        // 3) persisted active source
+        // 4) one-time prompt when multiple sources are registered
+        let resolvedSource = null;
+        const sourceDb = this.storage.getDatabase();
+        if (flags.from && flags['from-linear']) {
+            return handleError('CONFLICTING_SOURCE_FLAGS', '--from and --from-linear cannot be used together.');
+        }
+        if (flags.from) {
+            try {
+                resolvedSource = parseWorkSourceRef(flags.from);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Invalid value for --from';
+                return handleError('INVALID_SOURCE_OVERRIDE', message);
+            }
+        }
+        else if (flags['from-linear']) {
+            resolvedSource = {
+                provider: 'linear',
+                context: flags['linear-team'],
+            };
+        }
+        else {
+            const activeSource = loadActiveWorkSource(sourceDb);
+            if (activeSource) {
+                resolvedSource = activeSource;
+            }
+            else {
+                const registeredSources = getRegisteredWorkSources(sourceDb);
+                if (registeredSources.length > 1) {
+                    const selectedRef = await this.selectFromList({
+                        message: 'Select the default work source for this workspace:',
+                        items: registeredSources,
+                        getName: (source) => {
+                            const ref = formatWorkSourceRef(source);
+                            return source.provider === 'linear'
+                                ? `Linear (${source.context ?? 'default team'})`
+                                : ref.toUpperCase();
+                        },
+                        getValue: source => formatWorkSourceRef(source),
+                        getCommand: source => `prlt work spawn --from ${formatWorkSourceRef(source)} --json`,
+                        jsonMode: jsonMode ? { flags, commandName: 'work spawn' } : null,
+                    });
+                    if (!selectedRef) {
+                        return;
+                    }
+                    resolvedSource = parseWorkSourceRef(selectedRef);
+                    saveActiveWorkSource(sourceDb, resolvedSource);
+                    if (!jsonMode) {
+                        this.log(styles.muted(`Saved active work source: ${formatWorkSourceRef(resolvedSource)}`));
+                    }
+                }
+                else if (registeredSources.length === 1) {
+                    resolvedSource = registeredSources[0];
+                }
+            }
+        }
         // =========================================================================
-        // --from-linear: Pull Linear issues → mirror into PMO → spawn from PMO
+        // Linear source: Pull Linear issues → mirror into PMO → spawn from PMO
         // =========================================================================
-        if (flags['from-linear']) {
+        if (resolvedSource?.provider === 'linear') {
             const db = this.storage.getDatabase();
             if (!isLinearConfigured(db)) {
                 return handleError('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.');
@@ -208,7 +270,7 @@ export default class WorkSpawn extends PMOCommand {
                 jsonMode: jsonMode ? {
                     flags,
                     commandName: 'work spawn',
-                    baseCommand: 'prlt work spawn --from-linear',
+                    baseCommand: `prlt work spawn --from ${formatWorkSourceRef(resolvedSource)}`,
                 } : undefined,
             });
             // Get project workflow statuses for mapping
@@ -245,7 +307,7 @@ export default class WorkSpawn extends PMOCommand {
             else {
                 // Fetch issues using filters
                 const filter = {
-                    teamKey: flags['linear-team'] ?? linearConfig.defaultTeamKey,
+                    teamKey: resolvedSource.context ?? flags['linear-team'] ?? linearConfig.defaultTeamKey,
                     stateName: flags['linear-state'],
                     labelName: flags['linear-label'],
                     limit: flags['linear-limit'],
@@ -297,6 +359,9 @@ export default class WorkSpawn extends PMOCommand {
             // Replace ticket args with the imported PMO ticket IDs
             ticketIdArgs = pmoTicketIds;
         }
+        else if (resolvedSource && resolvedSource.provider !== 'pmo') {
+            return handleError('SOURCE_NOT_SUPPORTED', `Source "${resolvedSource.provider}" is configured but not supported by work spawn yet. Use --from pmo or --from linear[:team].`);
+        }
         // Try to infer project from ticket IDs if provided
         let projectId;
         if (ticketIdArgs.length > 0) {

package/dist/commands/work/start.d.ts

@@ -11,6 +11,10 @@ export default class WorkStart extends PMOCommand {
         action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         prompt: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'from-issue': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        source: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        key: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'mirror-to-pmo': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         watch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'vm-host': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -33,6 +37,10 @@ export default class WorkStart extends PMOCommand {
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    private findLinkedTicketByEnvelope;
+    private createOrUpdateLinkedTicket;
+    private fetchExternalIssue;
+    private resolveIssueSourceAndKey;
     execute(): Promise<void>;
     /**
      * Run batch mode: spawn work for all unassigned backlog tickets