@proletariat/cli 0.3.50 → 0.3.52

package/dist/lib/monday/mapper.js

@@ -0,0 +1,89 @@
+import { PMO_TABLES } from '../pmo/schema.js';
+export class MondayMapper {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.ensureTable();
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${PMO_TABLES.monday_item_map} (
+        pmo_ticket_id TEXT NOT NULL REFERENCES ${PMO_TABLES.tickets}(id) ON DELETE CASCADE,
+        monday_board_id TEXT NOT NULL,
+        monday_item_id TEXT NOT NULL,
+        monday_item_name TEXT NOT NULL,
+        monday_item_url TEXT,
+        sync_direction TEXT NOT NULL DEFAULT 'outbound',
+        last_synced_at TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (pmo_ticket_id),
+        UNIQUE (monday_item_id)
+      )
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_pmo_monday_item_map_item_id
+      ON ${PMO_TABLES.monday_item_map}(monday_item_id)
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_pmo_monday_item_map_board_id
+      ON ${PMO_TABLES.monday_item_map}(monday_board_id)
+    `);
+    }
+    createOrUpdateMapping(map) {
+        this.db.prepare(`
+      INSERT INTO ${PMO_TABLES.monday_item_map}
+        (pmo_ticket_id, monday_board_id, monday_item_id, monday_item_name, monday_item_url, sync_direction, last_synced_at, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT(pmo_ticket_id) DO UPDATE SET
+        monday_board_id = excluded.monday_board_id,
+        monday_item_id = excluded.monday_item_id,
+        monday_item_name = excluded.monday_item_name,
+        monday_item_url = excluded.monday_item_url,
+        sync_direction = excluded.sync_direction,
+        last_synced_at = CURRENT_TIMESTAMP
+    `).run(map.pmoTicketId, map.mondayBoardId, map.mondayItemId, map.mondayItemName, map.mondayItemUrl ?? null, map.syncDirection);
+    }
+    getByTicketId(ticketId) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.monday_item_map} WHERE pmo_ticket_id = ?
+    `).get(ticketId);
+        return row ? this.rowToMap(row) : null;
+    }
+    getByMondayItemId(itemId) {
+        const row = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.monday_item_map} WHERE monday_item_id = ?
+    `).get(itemId);
+        return row ? this.rowToMap(row) : null;
+    }
+    listMappings() {
+        const rows = this.db.prepare(`
+      SELECT * FROM ${PMO_TABLES.monday_item_map} ORDER BY created_at DESC
+    `).all();
+        return rows.map((row) => this.rowToMap(row));
+    }
+    updateSyncTimestamp(ticketId) {
+        this.db.prepare(`
+      UPDATE ${PMO_TABLES.monday_item_map}
+      SET last_synced_at = CURRENT_TIMESTAMP
+      WHERE pmo_ticket_id = ?
+    `).run(ticketId);
+    }
+    deleteMapping(ticketId) {
+        this.db.prepare(`
+      DELETE FROM ${PMO_TABLES.monday_item_map}
+      WHERE pmo_ticket_id = ?
+    `).run(ticketId);
+    }
+    rowToMap(row) {
+        return {
+            pmoTicketId: row.pmo_ticket_id,
+            mondayBoardId: row.monday_board_id,
+            mondayItemId: row.monday_item_id,
+            mondayItemName: row.monday_item_name,
+            mondayItemUrl: row.monday_item_url ?? undefined,
+            syncDirection: row.sync_direction,
+            lastSyncedAt: row.last_synced_at ? new Date(row.last_synced_at) : undefined,
+            createdAt: new Date(row.created_at),
+        };
+    }
+}

package/dist/lib/monday/sync.d.ts

@@ -0,0 +1,13 @@
+import type { Ticket } from '../pmo/types.js';
+import { MondayClient } from './client.js';
+import { MondayMapper } from './mapper.js';
+export declare class MondaySync {
+    private client;
+    private mapper;
+    constructor(client: MondayClient, mapper: MondayMapper);
+    syncTicket(ticket: Ticket, boardId: string): Promise<{
+        created: boolean;
+        itemId: string;
+    }>;
+    ticketToItemName(ticket: Ticket): string;
+}

package/dist/lib/monday/sync.js

@@ -0,0 +1,45 @@
+export class MondaySync {
+    client;
+    mapper;
+    constructor(client, mapper) {
+        this.client = client;
+        this.mapper = mapper;
+    }
+    async syncTicket(ticket, boardId) {
+        const itemName = this.ticketToItemName(ticket);
+        const mapping = this.mapper.getByTicketId(ticket.id);
+        if (mapping && mapping.mondayBoardId === boardId) {
+            if (mapping.mondayItemName !== itemName) {
+                await this.client.updateItemName(boardId, mapping.mondayItemId, itemName);
+            }
+            this.mapper.createOrUpdateMapping({
+                pmoTicketId: ticket.id,
+                mondayBoardId: boardId,
+                mondayItemId: mapping.mondayItemId,
+                mondayItemName: itemName,
+                mondayItemUrl: mapping.mondayItemUrl,
+                syncDirection: 'outbound',
+            });
+            return {
+                created: false,
+                itemId: mapping.mondayItemId,
+            };
+        }
+        const createdItem = await this.client.createItem(boardId, itemName);
+        this.mapper.createOrUpdateMapping({
+            pmoTicketId: ticket.id,
+            mondayBoardId: boardId,
+            mondayItemId: createdItem.id,
+            mondayItemName: createdItem.name,
+            mondayItemUrl: createdItem.url,
+            syncDirection: 'outbound',
+        });
+        return {
+            created: true,
+            itemId: createdItem.id,
+        };
+    }
+    ticketToItemName(ticket) {
+        return `${ticket.id}: ${ticket.title}`;
+    }
+}

package/dist/lib/monday/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Monday.com Integration Types
+ */
+export interface MondayBoard {
+    id: string;
+    name: string;
+    url?: string;
+}
+export interface MondayItem {
+    id: string;
+    name: string;
+    url?: string;
+}
+export interface MondayConfig {
+    apiToken: string;
+    boardId?: string;
+    boardName?: string;
+    accountName?: string;
+}
+export interface MondayItemMap {
+    pmoTicketId: string;
+    mondayBoardId: string;
+    mondayItemId: string;
+    mondayItemName: string;
+    mondayItemUrl?: string;
+    syncDirection: 'outbound' | 'bidirectional';
+    lastSyncedAt?: Date;
+    createdAt: Date;
+}
+export interface MondaySyncResult {
+    synced: number;
+    created: number;
+    skipped: number;
+    errors: Array<{
+        ticketId: string;
+        error: string;
+    }>;
+}

package/dist/lib/monday/types.js

@@ -0,0 +1,4 @@
+/**
+ * Monday.com Integration Types
+ */
+export {};

package/dist/lib/pmo/schema.d.ts

@@ -39,6 +39,11 @@ export declare const PMO_TABLES: {
     readonly labels: "pmo_labels";
     readonly ticket_labels: "pmo_ticket_labels";
     readonly linear_issue_map: "pmo_linear_issue_map";
+    readonly external_execution_map: "pmo_external_execution_map";
+    readonly external_execution_links: "pmo_external_execution_links";
+    readonly external_execution_prs: "pmo_external_execution_prs";
+    readonly monday_item_map: "pmo_monday_item_map";
+    readonly asana_task_map: "pmo_asana_task_map";
     readonly columns: "pmo_columns";
     readonly board_tickets: "pmo_board_tickets";
     readonly statuses: "pmo_statuses";
@@ -67,7 +72,7 @@ export declare const PMO_TABLE_SCHEMAS: {
     readonly project_specs: "\n    CREATE TABLE IF NOT EXISTS pmo_project_specs (\n      project_id TEXT NOT NULL REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      spec_id TEXT NOT NULL REFERENCES pmo_specs(id) ON DELETE CASCADE,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (project_id, spec_id)\n    )";
     readonly cache_metadata: "\n    CREATE TABLE IF NOT EXISTS pmo_cache_metadata (\n      key TEXT PRIMARY KEY,\n      value TEXT NOT NULL\n    )";
     readonly settings: "\n    CREATE TABLE IF NOT EXISTS pmo_settings (\n      key TEXT PRIMARY KEY,\n      value TEXT NOT NULL\n    )";
-    readonly agent_work: "\n    CREATE TABLE IF NOT EXISTS agent_work (\n      id TEXT PRIMARY KEY,\n      ticket_id TEXT NOT NULL,\n      agent_name TEXT NOT NULL,\n      executor TEXT NOT NULL,\n      environment TEXT NOT NULL DEFAULT 'host',\n      display_mode TEXT NOT NULL DEFAULT 'terminal',\n      permission_mode TEXT NOT NULL DEFAULT 'safe',\n      status TEXT NOT NULL DEFAULT 'starting',\n      branch TEXT,\n      pid TEXT,\n      container_id TEXT,\n      session_id TEXT,\n      host TEXT,\n      log_path TEXT,\n      started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      completed_at TIMESTAMP,\n      exit_code INTEGER,\n      error_message TEXT,\n      FOREIGN KEY (ticket_id) REFERENCES pmo_tickets(id) ON DELETE CASCADE\n    )";
+    readonly agent_work: "\n    CREATE TABLE IF NOT EXISTS agent_work (\n      id TEXT PRIMARY KEY,\n      ticket_id TEXT NOT NULL,\n      agent_name TEXT NOT NULL,\n      executor TEXT NOT NULL,\n      environment TEXT NOT NULL DEFAULT 'host',\n      display_mode TEXT NOT NULL DEFAULT 'terminal',\n      permission_mode TEXT NOT NULL DEFAULT 'safe',\n      status TEXT NOT NULL DEFAULT 'starting',\n      branch TEXT,\n      pid TEXT,\n      container_id TEXT,\n      session_id TEXT,\n      host TEXT,\n      log_path TEXT,\n      external_source TEXT,\n      external_key TEXT,\n      external_id TEXT,\n      external_url TEXT,\n      started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      completed_at TIMESTAMP,\n      exit_code INTEGER,\n      error_message TEXT,\n      FOREIGN KEY (ticket_id) REFERENCES pmo_tickets(id) ON DELETE CASCADE\n    )";
     readonly containers: "\n    CREATE TABLE IF NOT EXISTS containers (\n      id TEXT PRIMARY KEY,\n      agent_name TEXT NOT NULL,\n      docker_id TEXT NOT NULL,\n      docker_name TEXT,\n      image TEXT,\n      status TEXT NOT NULL DEFAULT 'unknown',\n      current_execution_id TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      last_seen_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (agent_name) REFERENCES agents(name) ON DELETE CASCADE,\n      FOREIGN KEY (current_execution_id) REFERENCES agent_work(id) ON DELETE SET NULL\n    )";
     readonly id_sequences: "\n    CREATE TABLE IF NOT EXISTS id_sequences (\n      table_name TEXT PRIMARY KEY,\n      next_id INTEGER NOT NULL DEFAULT 1\n    )";
     readonly statuses: "\n    CREATE TABLE IF NOT EXISTS pmo_statuses (\n      id TEXT PRIMARY KEY,\n      project_id TEXT NOT NULL,\n      name TEXT NOT NULL,\n      category TEXT NOT NULL,\n      position INTEGER NOT NULL DEFAULT 0,\n      color TEXT,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (project_id) REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      UNIQUE(project_id, name)\n    )";
@@ -81,6 +86,10 @@ export declare const PMO_TABLE_SCHEMAS: {
     readonly roadmaps: "\n    CREATE TABLE IF NOT EXISTS pmo_roadmaps (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly roadmap_projects: "\n    CREATE TABLE IF NOT EXISTS pmo_roadmap_projects (\n      roadmap_id TEXT NOT NULL REFERENCES pmo_roadmaps(id) ON DELETE CASCADE,\n      project_id TEXT NOT NULL REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      position INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (roadmap_id, project_id)\n    )";
     readonly linear_issue_map: "\n    CREATE TABLE IF NOT EXISTS pmo_linear_issue_map (\n      pmo_ticket_id TEXT NOT NULL REFERENCES pmo_tickets(id) ON DELETE CASCADE,\n      linear_issue_id TEXT NOT NULL,\n      linear_identifier TEXT NOT NULL,\n      linear_team_key TEXT NOT NULL,\n      linear_url TEXT NOT NULL,\n      sync_direction TEXT NOT NULL DEFAULT 'inbound',\n      last_synced_at TIMESTAMP,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (pmo_ticket_id),\n      UNIQUE (linear_issue_id)\n    )";
+    readonly external_execution_map: "\n    CREATE TABLE IF NOT EXISTS pmo_external_execution_map (\n      provider TEXT NOT NULL CHECK (provider IN ('linear', 'jira', 'asana', 'monday', 'pmo')),\n      external_id TEXT NOT NULL,\n      external_key TEXT,\n      canonical_url TEXT,\n      latest_state_snapshot TEXT,\n      last_synced_at TIMESTAMP,\n      last_spawned_at TIMESTAMP,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (provider, external_id)\n    )";
+    readonly external_execution_links: "\n    CREATE TABLE IF NOT EXISTS pmo_external_execution_links (\n      provider TEXT NOT NULL,\n      external_id TEXT NOT NULL,\n      execution_id TEXT NOT NULL,\n      linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (provider, external_id, execution_id),\n      FOREIGN KEY (provider, external_id)\n        REFERENCES pmo_external_execution_map(provider, external_id)\n        ON DELETE CASCADE\n    )";
+    readonly external_execution_prs: "\n    CREATE TABLE IF NOT EXISTS pmo_external_execution_prs (\n      provider TEXT NOT NULL,\n      external_id TEXT NOT NULL,\n      pr_url TEXT NOT NULL,\n      linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (provider, external_id, pr_url),\n      FOREIGN KEY (provider, external_id)\n        REFERENCES pmo_external_execution_map(provider, external_id)\n        ON DELETE CASCADE\n    )";
+    readonly monday_item_map: "\n    CREATE TABLE IF NOT EXISTS pmo_monday_item_map (\n      pmo_ticket_id TEXT NOT NULL REFERENCES pmo_tickets(id) ON DELETE CASCADE,\n      monday_board_id TEXT NOT NULL,\n      monday_item_id TEXT NOT NULL,\n      monday_item_name TEXT NOT NULL,\n      monday_item_url TEXT,\n      sync_direction TEXT NOT NULL DEFAULT 'outbound',\n      last_synced_at TIMESTAMP,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (pmo_ticket_id),\n      UNIQUE (monday_item_id)\n    )";
 };
 export declare const PMO_INDEXES: string;
 /**

package/dist/lib/pmo/schema.js

@@ -47,6 +47,14 @@ export const PMO_TABLES = {
     ticket_labels: 'pmo_ticket_labels',
     // Linear integration tables
     linear_issue_map: 'pmo_linear_issue_map', // Linear issue ↔ PMO ticket mapping
+    // Provider-agnostic external issue/execution mapping
+    external_execution_map: 'pmo_external_execution_map',
+    external_execution_links: 'pmo_external_execution_links',
+    external_execution_prs: 'pmo_external_execution_prs',
+    // Monday.com integration tables
+    monday_item_map: 'pmo_monday_item_map', // Monday item ↔ PMO ticket mapping
+    // Asana integration tables
+    asana_task_map: 'pmo_asana_task_map', // Asana task ↔ PMO ticket mapping
     // Legacy tables (deprecated, kept for migration)
     columns: 'pmo_columns', // DEPRECATED: use workflow_statuses
     board_tickets: 'pmo_board_tickets', // DEPRECATED: tickets now use status_id directly
@@ -336,6 +344,10 @@ export const PMO_TABLE_SCHEMAS = {
       session_id TEXT,
       host TEXT,
       log_path TEXT,
+      external_source TEXT,
+      external_key TEXT,
+      external_id TEXT,
+      external_url TEXT,
       started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       completed_at TIMESTAMP,
       exit_code INTEGER,
@@ -498,6 +510,58 @@ export const PMO_TABLE_SCHEMAS = {
       PRIMARY KEY (pmo_ticket_id),
       UNIQUE (linear_issue_id)
     )`,
+    // Provider-agnostic external issue ↔ execution mapping
+    external_execution_map: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.external_execution_map} (
+      provider TEXT NOT NULL CHECK (provider IN ('linear', 'jira', 'asana', 'monday', 'pmo')),
+      external_id TEXT NOT NULL,
+      external_key TEXT,
+      canonical_url TEXT,
+      latest_state_snapshot TEXT,
+      last_synced_at TIMESTAMP,
+      last_spawned_at TIMESTAMP,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (provider, external_id)
+    )`,
+    // Linked execution IDs for external mappings
+    external_execution_links: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.external_execution_links} (
+      provider TEXT NOT NULL,
+      external_id TEXT NOT NULL,
+      execution_id TEXT NOT NULL,
+      linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (provider, external_id, execution_id),
+      FOREIGN KEY (provider, external_id)
+        REFERENCES ${PMO_TABLES.external_execution_map}(provider, external_id)
+        ON DELETE CASCADE
+    )`,
+    // Linked PR URLs for external mappings
+    external_execution_prs: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.external_execution_prs} (
+      provider TEXT NOT NULL,
+      external_id TEXT NOT NULL,
+      pr_url TEXT NOT NULL,
+      linked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (provider, external_id, pr_url),
+      FOREIGN KEY (provider, external_id)
+        REFERENCES ${PMO_TABLES.external_execution_map}(provider, external_id)
+        ON DELETE CASCADE
+    )`,
+    // Monday.com integration: item ↔ PMO ticket mapping
+    monday_item_map: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.monday_item_map} (
+      pmo_ticket_id TEXT NOT NULL REFERENCES ${PMO_TABLES.tickets}(id) ON DELETE CASCADE,
+      monday_board_id TEXT NOT NULL,
+      monday_item_id TEXT NOT NULL,
+      monday_item_name TEXT NOT NULL,
+      monday_item_url TEXT,
+      sync_direction TEXT NOT NULL DEFAULT 'outbound',
+      last_synced_at TIMESTAMP,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (pmo_ticket_id),
+      UNIQUE (monday_item_id)
+    )`,
 };
 // =============================================================================
 // Indexes
@@ -563,6 +627,11 @@ export const PMO_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_pmo_linear_issue_map_linear_id ON ${PMO_TABLES.linear_issue_map}(linear_issue_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_linear_issue_map_identifier ON ${PMO_TABLES.linear_issue_map}(linear_identifier);
   CREATE INDEX IF NOT EXISTS idx_pmo_linear_issue_map_team ON ${PMO_TABLES.linear_issue_map}(linear_team_key);
+  CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_map_external_key ON ${PMO_TABLES.external_execution_map}(provider, external_key);
+  CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_links_execution_id ON ${PMO_TABLES.external_execution_links}(execution_id);
+  CREATE INDEX IF NOT EXISTS idx_pmo_external_execution_prs_pr_url ON ${PMO_TABLES.external_execution_prs}(pr_url);
+  CREATE INDEX IF NOT EXISTS idx_pmo_monday_item_map_item_id ON ${PMO_TABLES.monday_item_map}(monday_item_id);
+  CREATE INDEX IF NOT EXISTS idx_pmo_monday_item_map_board_id ON ${PMO_TABLES.monday_item_map}(monday_board_id);
 `;
 // =============================================================================
 // Combined Schema
@@ -607,6 +676,10 @@ export const PMO_SCHEMA_SQL = [
     PMO_TABLE_SCHEMAS.roadmaps, // Named roadmap definitions
     PMO_TABLE_SCHEMAS.roadmap_projects, // Roadmap-to-project associations
     PMO_TABLE_SCHEMAS.linear_issue_map, // Linear issue ↔ PMO ticket mapping
+    PMO_TABLE_SCHEMAS.external_execution_map, // External issue ↔ execution mapping
+    PMO_TABLE_SCHEMAS.external_execution_links, // External issue ↔ execution links
+    PMO_TABLE_SCHEMAS.external_execution_prs, // External issue ↔ PR links
+    PMO_TABLE_SCHEMAS.monday_item_map, // Monday item ↔ PMO ticket mapping
     // Legacy tables (kept for migration, will be dropped after data migrated)
     PMO_TABLE_SCHEMAS.columns, // DEPRECATED
     PMO_TABLE_SCHEMAS.board_tickets, // DEPRECATED

package/dist/lib/pmo/storage/base.js

@@ -295,6 +295,38 @@ export function runMigrations(db) {
                 // Column may already exist
             }
         }
+        if (!agentWorkColumnNames.has('external_source')) {
+            try {
+                db.exec(`ALTER TABLE ${T.agent_work} ADD COLUMN external_source TEXT`);
+            }
+            catch {
+                // Column may already exist
+            }
+        }
+        if (!agentWorkColumnNames.has('external_key')) {
+            try {
+                db.exec(`ALTER TABLE ${T.agent_work} ADD COLUMN external_key TEXT`);
+            }
+            catch {
+                // Column may already exist
+            }
+        }
+        if (!agentWorkColumnNames.has('external_id')) {
+            try {
+                db.exec(`ALTER TABLE ${T.agent_work} ADD COLUMN external_id TEXT`);
+            }
+            catch {
+                // Column may already exist
+            }
+        }
+        if (!agentWorkColumnNames.has('external_url')) {
+            try {
+                db.exec(`ALTER TABLE ${T.agent_work} ADD COLUMN external_url TEXT`);
+            }
+            catch {
+                // Column may already exist
+            }
+        }
     }
     // Migration: Reassign orphaned tickets (TKT-940)
     // Tickets with project_id that doesn't match any existing project are "orphaned".

package/dist/lib/prompt-json.d.ts

@@ -92,6 +92,17 @@ export interface OutputMetadata {
     prModeSource?: string;
     /** Warning message when PR creation is disabled for code-modifying actions */
     prWarning?: string;
+    /** External issue context propagated by work start confirmation flow */
+    externalIssue?: {
+        source: string | null;
+        key: string | null;
+        id: string | null;
+        url: string | null;
+    };
+    /** Resolved mirror-to-PMO behavior for --from-issue flow */
+    mirrorToPmo?: boolean | null;
+    /** Source used to resolve mirror-to-PMO behavior */
+    mirrorToPmoSource?: string | null;
 }
 /**
  * JSON output when a prompt would be shown

package/dist/lib/work-source/config.d.ts

@@ -0,0 +1,14 @@
+import Database from 'better-sqlite3';
+export declare const WORK_SOURCE_PROVIDERS: readonly ["pmo", "linear", "jira", "asana", "monday"];
+export type WorkSourceProvider = typeof WORK_SOURCE_PROVIDERS[number];
+export interface WorkSourceRef {
+    provider: WorkSourceProvider;
+    context?: string;
+}
+export declare function isWorkSourceProvider(value: string): value is WorkSourceProvider;
+export declare function parseWorkSourceRef(input: string): WorkSourceRef;
+export declare function formatWorkSourceRef(source: WorkSourceRef): string;
+export declare function saveActiveWorkSource(db: Database.Database, source: WorkSourceRef): void;
+export declare function clearActiveWorkSource(db: Database.Database): void;
+export declare function loadActiveWorkSource(db: Database.Database): WorkSourceRef | null;
+export declare function getRegisteredWorkSources(db: Database.Database): WorkSourceRef[];

package/dist/lib/work-source/config.js

@@ -0,0 +1,70 @@
+import { loadLinearConfig } from '../linear/config.js';
+const SETTINGS_TABLE = 'workspace_settings';
+const ACTIVE_SOURCE_KEY = 'work.active_source';
+export const WORK_SOURCE_PROVIDERS = ['pmo', 'linear', 'jira', 'asana', 'monday'];
+function getSetting(db, key) {
+    const row = db
+        .prepare(`SELECT value FROM ${SETTINGS_TABLE} WHERE key = ?`)
+        .get(key);
+    return row?.value ?? null;
+}
+function setSetting(db, key, value) {
+    db.prepare(`
+    INSERT INTO ${SETTINGS_TABLE} (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+function deleteSetting(db, key) {
+    db.prepare(`DELETE FROM ${SETTINGS_TABLE} WHERE key = ?`).run(key);
+}
+export function isWorkSourceProvider(value) {
+    return WORK_SOURCE_PROVIDERS.includes(value);
+}
+export function parseWorkSourceRef(input) {
+    const raw = input.trim();
+    if (!raw) {
+        throw new Error('Work source cannot be empty.');
+    }
+    const separatorIndex = raw.indexOf(':');
+    const providerText = separatorIndex === -1 ? raw : raw.slice(0, separatorIndex);
+    const provider = providerText.toLowerCase();
+    if (!isWorkSourceProvider(provider)) {
+        throw new Error(`Unsupported work source provider "${providerText}". Allowed: ${WORK_SOURCE_PROVIDERS.join(', ')}`);
+    }
+    const rawContext = separatorIndex === -1 ? '' : raw.slice(separatorIndex + 1).trim();
+    const context = rawContext.length > 0 ? rawContext : undefined;
+    return { provider, context };
+}
+export function formatWorkSourceRef(source) {
+    return source.context ? `${source.provider}:${source.context}` : source.provider;
+}
+export function saveActiveWorkSource(db, source) {
+    setSetting(db, ACTIVE_SOURCE_KEY, formatWorkSourceRef(source));
+}
+export function clearActiveWorkSource(db) {
+    deleteSetting(db, ACTIVE_SOURCE_KEY);
+}
+export function loadActiveWorkSource(db) {
+    const raw = getSetting(db, ACTIVE_SOURCE_KEY);
+    if (!raw)
+        return null;
+    try {
+        return parseWorkSourceRef(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function getRegisteredWorkSources(db) {
+    const providers = new Map();
+    providers.set('pmo', { provider: 'pmo' });
+    const linearConfig = loadLinearConfig(db);
+    if (linearConfig) {
+        providers.set('linear', {
+            provider: 'linear',
+            context: linearConfig.defaultTeamKey ?? undefined,
+        });
+    }
+    return Array.from(providers.values());
+}

package/dist/lib/work-source/index.d.ts

@@ -0,0 +1 @@
+export { WORK_SOURCE_PROVIDERS, type WorkSourceProvider, type WorkSourceRef, isWorkSourceProvider, parseWorkSourceRef, formatWorkSourceRef, saveActiveWorkSource, clearActiveWorkSource, loadActiveWorkSource, getRegisteredWorkSources, } from './config.js';

package/dist/lib/work-source/index.js

@@ -0,0 +1 @@
+export { WORK_SOURCE_PROVIDERS, isWorkSourceProvider, parseWorkSourceRef, formatWorkSourceRef, saveActiveWorkSource, clearActiveWorkSource, loadActiveWorkSource, getRegisteredWorkSources, } from './config.js';