claude-dashboard 0.2.0 → 0.4.0

package/dist/src/lib/db/queries.js

@@ -1,6 +1,6 @@
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from "./connection.js";
-import { AGENT_ORDER, } from "../workflow/types.js";
+import { AGENT_ORDER, normalizeExecutionPlan, } from "../workflow/types.js";
 function rowToWorkflow(row) {
     return {
         id: row.id,
@@ -35,11 +35,12 @@ function rowToStep(row) {
 // Workflow CRUD
 // ---------------------------------------------------------------------------
 /**
- * Create a new workflow together with its five agent-step rows (one per role
- * in `AGENT_ORDER`).  Everything runs inside a single transaction so that the
- * workflow and its steps are always created atomically.
+ * Create a new workflow together with one agent-step row per role in
+ * `AGENT_ORDER`. Steps outside the requested execution plan are marked as
+ * `skipped`. Everything runs inside a single transaction so workflow + steps
+ * are always created atomically.
  */
-export function createWorkflow(id, title, userPrompt, projectPath) {
+export function createWorkflow(id, title, userPrompt, projectPath, executionPlan) {
     const db = getDb();
     const insertWorkflow = db.prepare(`
     INSERT INTO workflows (id, title, user_prompt, status, current_step_index, project_path)
@@ -47,8 +48,9 @@ export function createWorkflow(id, title, userPrompt, projectPath) {
   `);
     const insertStep = db.prepare(`
     INSERT INTO agent_steps (id, workflow_id, role, status)
-    VALUES (@id, @workflowId, @role, 'pending')
+    VALUES (@id, @workflowId, @role, @status)
   `);
+    const selected = new Set(normalizeExecutionPlan(executionPlan));
     const txn = db.transaction(() => {
         insertWorkflow.run({ id, title, userPrompt, projectPath });
         for (const role of AGENT_ORDER) {
@@ -56,6 +58,7 @@ export function createWorkflow(id, title, userPrompt, projectPath) {
                 id: uuidv4(),
                 workflowId: id,
                 role,
+                status: selected.has(role) ? 'pending' : 'skipped',
             });
         }
     });
@@ -71,15 +74,44 @@ export function getWorkflow(id) {
     const row = stmt.get(id);
     return row ? rowToWorkflow(row) : null;
 }
-/**
- * List workflows ordered by creation time (newest first).
- */
-export function listWorkflows(limit = 50, offset = 0) {
+export function listWorkflows(limit = 50, offset = 0, filters) {
     const db = getDb();
-    const stmt = db.prepare('SELECT * FROM workflows ORDER BY created_at DESC LIMIT ? OFFSET ?');
-    const rows = stmt.all(limit, offset);
+    const where = [];
+    const params = {
+        limit,
+        offset,
+    };
+    if (filters === null || filters === void 0 ? void 0 : filters.status) {
+        where.push('status = @status');
+        params.status = filters.status;
+    }
+    if ((filters === null || filters === void 0 ? void 0 : filters.q) && filters.q.trim()) {
+        where.push('(title LIKE @q OR user_prompt LIKE @q)');
+        params.q = `%${filters.q.trim()}%`;
+    }
+    const whereSql = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+    const stmt = db.prepare(`SELECT * FROM workflows ${whereSql} ORDER BY created_at DESC LIMIT @limit OFFSET @offset`);
+    const rows = stmt.all(params);
     return rows.map(rowToWorkflow);
 }
+export function countWorkflows(filters) {
+    var _a;
+    const db = getDb();
+    const where = [];
+    const params = {};
+    if (filters === null || filters === void 0 ? void 0 : filters.status) {
+        where.push('status = @status');
+        params.status = filters.status;
+    }
+    if ((filters === null || filters === void 0 ? void 0 : filters.q) && filters.q.trim()) {
+        where.push('(title LIKE @q OR user_prompt LIKE @q)');
+        params.q = `%${filters.q.trim()}%`;
+    }
+    const whereSql = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+    const stmt = db.prepare(`SELECT COUNT(*) as count FROM workflows ${whereSql}`);
+    const row = (Object.keys(params).length > 0 ? stmt.get(params) : stmt.get());
+    return (_a = row === null || row === void 0 ? void 0 : row.count) !== null && _a !== void 0 ? _a : 0;
+}
 /**
  * Update a workflow's status (and optionally the current step index).
  *
@@ -167,3 +199,70 @@ export function updateStepStatus(id, updates) {
     const sql = `UPDATE agent_steps SET ${setClauses.join(', ')} WHERE id = @id`;
     db.prepare(sql).run(params);
 }
+export function cleanupWorkflows(policy) {
+    var _a, _b;
+    const db = getDb();
+    const keepDays = (_a = policy.keepDays) !== null && _a !== void 0 ? _a : 0;
+    const keepLatest = (_b = policy.keepLatest) !== null && _b !== void 0 ? _b : 0;
+    const idsToDelete = new Set();
+    if (keepDays > 0) {
+        const oldRows = db
+            .prepare(`SELECT id FROM workflows WHERE datetime(created_at) < datetime('now', @cutoff)`)
+            .all({ cutoff: `-${keepDays} days` });
+        for (const row of oldRows)
+            idsToDelete.add(row.id);
+    }
+    if (keepLatest > 0) {
+        const overflowRows = db
+            .prepare(`SELECT id FROM workflows ORDER BY datetime(created_at) DESC LIMIT -1 OFFSET @offset`)
+            .all({ offset: keepLatest });
+        for (const row of overflowRows)
+            idsToDelete.add(row.id);
+    }
+    if (idsToDelete.size === 0)
+        return { deleted: 0 };
+    const deleteStep = db.prepare('DELETE FROM agent_steps WHERE workflow_id = ?');
+    const deleteWorkflow = db.prepare('DELETE FROM workflows WHERE id = ?');
+    const txn = db.transaction(() => {
+        for (const id of idsToDelete) {
+            deleteStep.run(id);
+            deleteWorkflow.run(id);
+        }
+    });
+    txn();
+    return { deleted: idsToDelete.size };
+}
+export function getWorkflowMetrics() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const db = getDb();
+    const workflowRow = db.prepare(`
+    SELECT
+      COUNT(*) as workflow_count,
+      SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_count,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_count,
+      AVG(
+        CASE
+          WHEN completed_at IS NOT NULL
+          THEN (julianday(completed_at) - julianday(created_at)) * 86400000
+          ELSE NULL
+        END
+      ) as avg_workflow_duration_ms
+    FROM workflows
+  `).get();
+    const stepRow = db.prepare(`
+    SELECT
+      AVG(duration_ms) as avg_step_duration_ms,
+      SUM(COALESCE(tokens_in, 0)) as total_tokens_in,
+      SUM(COALESCE(tokens_out, 0)) as total_tokens_out
+    FROM agent_steps
+  `).get();
+    return {
+        workflowCount: Number((_a = workflowRow === null || workflowRow === void 0 ? void 0 : workflowRow.workflow_count) !== null && _a !== void 0 ? _a : 0),
+        completedCount: Number((_b = workflowRow === null || workflowRow === void 0 ? void 0 : workflowRow.completed_count) !== null && _b !== void 0 ? _b : 0),
+        failedCount: Number((_c = workflowRow === null || workflowRow === void 0 ? void 0 : workflowRow.failed_count) !== null && _c !== void 0 ? _c : 0),
+        avgWorkflowDurationMs: Number((_d = workflowRow === null || workflowRow === void 0 ? void 0 : workflowRow.avg_workflow_duration_ms) !== null && _d !== void 0 ? _d : 0),
+        avgStepDurationMs: Number((_e = stepRow === null || stepRow === void 0 ? void 0 : stepRow.avg_step_duration_ms) !== null && _e !== void 0 ? _e : 0),
+        totalTokensIn: Number((_f = stepRow === null || stepRow === void 0 ? void 0 : stepRow.total_tokens_in) !== null && _f !== void 0 ? _f : 0),
+        totalTokensOut: Number((_g = stepRow === null || stepRow === void 0 ? void 0 : stepRow.total_tokens_out) !== null && _g !== void 0 ? _g : 0),
+    };
+}

package/dist/src/lib/i18n/messages.js

@@ -0,0 +1,238 @@
+export const SUPPORTED_LOCALES = ["en", "zh-TW"];
+export const DEFAULT_LOCALE = "en";
+export const messages = {
+    en: {
+        "app.title": "Claude Dashboard",
+        "nav.dashboard": "Dashboard",
+        "nav.history": "History",
+        "nav.events": "Events",
+        "nav.terminal": "Terminal",
+        "nav.toggleEvents": "Toggle event log panel",
+        "nav.toggleTerminal": "Toggle terminal panel",
+        "nav.agentsProgress": "{completed}/{total} agents",
+        "nav.language": "Language",
+        "launcher.templates": "Templates:",
+        "launcher.placeholder": "Describe your development task...",
+        "launcher.start": "Start",
+        "launcher.pause": "Pause",
+        "launcher.resume": "Resume",
+        "launcher.cancel": "Cancel",
+        "launcher.preview": "Preview",
+        "launcher.runMode": "Run mode:",
+        "launcher.mode.full": "Full (PM/RD/UI/TEST/SEC)",
+        "launcher.mode.fast": "Fast (skip TEST/SEC)",
+        "launcher.mode.custom": "Custom",
+        "launcher.warning.skip": "⚠️ This run will skip {roles}.",
+        "launcher.impact": "Impact: {level}",
+        "launcher.suggestedMode": "Suggested mode: {mode}",
+        "launcher.applySuggestion": "Apply suggestion",
+        "launcher.impact.low.reason": "Looks like a small scoped task. Fast mode is probably sufficient.",
+        "launcher.impact.medium.reason": "Likely multi-file change. Consider Full mode or at least include TEST.",
+        "launcher.impact.high.reason": "Prompt touches sensitive or high-risk areas. Keep TEST and SEC enabled.",
+        "history.title": "Workflow History",
+        "history.filters.allStatuses": "All statuses",
+        "history.filters.searchPlaceholder": "Search title or prompt",
+        "history.filters.search": "Search",
+        "history.retention": "Retention cleanup:",
+        "history.keepDays": "keep days",
+        "history.keepLatest": "keep latest",
+        "history.runCleanup": "Run Cleanup",
+        "history.loading": "Loading...",
+        "history.empty": "No workflows found.",
+        "history.table.title": "Title",
+        "history.table.status": "Status",
+        "history.table.created": "Created",
+        "history.table.duration": "Duration",
+        "history.pagination.prev": "Prev",
+        "history.pagination.next": "Next",
+        "history.metrics.workflows": "Workflows",
+        "history.metrics.completedFailed": "Completed / Failed",
+        "history.metrics.avgWorkflow": "Avg workflow",
+        "history.metrics.avgStep": "Avg step",
+        "history.metrics.tokensIn": "Tokens in",
+        "history.metrics.tokensOut": "Tokens out",
+        "history.pagination.summary": "{total} total · page {page}/{totalPages}",
+        "history.loadFailed": "Failed to load workflows: {error}",
+        "history.cleanup.confirm": "Cleanup history with policy: keep {keepDays} days OR latest {keepLatest} workflows?",
+        "history.cleanup.failed": "Cleanup failed",
+        "history.cleanup.success": "Cleanup complete: deleted {count} workflows.",
+        "pipeline.done": "Done",
+        "status.pending": "Pending",
+        "status.running": "Running",
+        "status.paused": "Paused",
+        "status.completed": "Done",
+        "status.failed": "Failed",
+        "status.skipped": "Skipped",
+        "status.cancelled": "Cancelled",
+        "agent.retry": "retry {count}",
+        "agent.tokens.in": "In: {value}",
+        "agent.tokens.out": "Out: {value}",
+        "agent.output.none": "No output yet",
+        "agent.activity.thinking": "Thinking...",
+        "agent.activity.toolUse": "Using {tool}...",
+        "agent.activity.writing": "Writing response...",
+        "agent.activity.waiting": "Waiting for output...",
+        "events.title": "Event Log",
+        "events.count": "{count} events",
+        "events.connected": "Connected to server",
+        "events.workflowStarted": "Workflow started: {title}",
+        "events.workflowCompleted": "Workflow completed successfully",
+        "events.workflowFailed": "Workflow failed: {error}",
+        "events.workflowPaused": "Workflow paused",
+        "events.workflowCancelled": "Workflow cancelled",
+        "events.agentStarted": "{agent} agent started{retry}",
+        "events.agentCompleted": "{agent} agent completed in {seconds}s",
+        "events.agentFailed": "{agent} agent failed: {error}",
+        "events.agentRetry": "{agent} agent retrying ({attempt}/{max}): {reason}",
+        "events.retrySuffix": " (retry {count})",
+        "usage.loadingAria": "Loading usage data",
+        "usage.unavailableAria": "Usage data unavailable",
+        "usage.unavailable": "Usage: --",
+        "usage.session": "Session",
+        "usage.week": "Week",
+        "usage.sonnet": "Sonnet",
+        "usage.tooltip.session": "Current Session (5h window)",
+        "usage.tooltip.week": "Weekly All Models (7 days)",
+        "usage.tooltip.sonnet": "Weekly Sonnet (7 days)",
+        "usage.tooltip.usage": "Usage: {value}",
+        "usage.tooltip.resets": "Resets: {value}",
+        "usage.tooltip.na": "N/A",
+        "terminal.title": "Terminal",
+        "terminal.connecting": "Connecting to server...",
+        "terminal.connected": "Connected",
+        "terminal.initializing": "Initializing...",
+        "terminal.error": "Error",
+        "historyDetail.title": "Workflow Detail",
+        "historyDetail.back": "← Back to History",
+        "historyDetail.loading": "Loading...",
+        "historyDetail.loadFailed": "Failed to load: {error}",
+        "historyDetail.meta.title": "Title:",
+        "historyDetail.meta.status": "Status:",
+        "historyDetail.meta.created": "Created:",
+        "historyDetail.meta.completed": "Completed:",
+        "historyDetail.retryWorkflow": "Retry entire workflow as new run",
+        "historyDetail.artifacts.title": "Run artifact summary (detected file paths)",
+        "historyDetail.artifacts.empty": "No file paths detected from agent outputs.",
+        "historyDetail.step.retry": "Retry from this step as new run",
+        "historyDetail.step.noOutput": "(no output)",
+        "historyDetail.step.in": "in",
+        "historyDetail.step.out": "out",
+    },
+    "zh-TW": {
+        "app.title": "Claude 儀表板",
+        "nav.dashboard": "儀表板",
+        "nav.history": "歷史",
+        "nav.events": "事件",
+        "nav.terminal": "終端機",
+        "nav.toggleEvents": "切換事件面板",
+        "nav.toggleTerminal": "切換終端機面板",
+        "nav.agentsProgress": "{completed}/{total} 個代理",
+        "nav.language": "語言",
+        "launcher.templates": "模板：",
+        "launcher.placeholder": "描述你的開發任務...",
+        "launcher.start": "開始",
+        "launcher.pause": "暫停",
+        "launcher.resume": "繼續",
+        "launcher.cancel": "取消",
+        "launcher.preview": "預估",
+        "launcher.runMode": "執行模式：",
+        "launcher.mode.full": "完整（PM/RD/UI/TEST/SEC）",
+        "launcher.mode.fast": "快速（略過 TEST/SEC）",
+        "launcher.mode.custom": "自訂",
+        "launcher.warning.skip": "⚠️ 此次執行將略過 {roles}。",
+        "launcher.impact": "影響：{level}",
+        "launcher.suggestedMode": "建議模式：{mode}",
+        "launcher.applySuggestion": "套用建議",
+        "launcher.impact.low.reason": "看起來是小範圍任務，快速模式應該足夠。",
+        "launcher.impact.medium.reason": "可能會動到多個檔案，建議完整模式或至少包含 TEST。",
+        "launcher.impact.high.reason": "涉及敏感或高風險區域，建議保留 TEST 與 SEC。",
+        "history.title": "工作流程歷史",
+        "history.filters.allStatuses": "所有狀態",
+        "history.filters.searchPlaceholder": "搜尋標題或提示詞",
+        "history.filters.search": "搜尋",
+        "history.retention": "保留清理：",
+        "history.keepDays": "保留天數",
+        "history.keepLatest": "保留最新",
+        "history.runCleanup": "執行清理",
+        "history.loading": "載入中...",
+        "history.empty": "找不到工作流程。",
+        "history.table.title": "標題",
+        "history.table.status": "狀態",
+        "history.table.created": "建立時間",
+        "history.table.duration": "耗時",
+        "history.pagination.prev": "上一頁",
+        "history.pagination.next": "下一頁",
+        "history.metrics.workflows": "工作流程數",
+        "history.metrics.completedFailed": "完成 / 失敗",
+        "history.metrics.avgWorkflow": "平均流程",
+        "history.metrics.avgStep": "平均步驟",
+        "history.metrics.tokensIn": "輸入 tokens",
+        "history.metrics.tokensOut": "輸出 tokens",
+        "history.pagination.summary": "共 {total} 筆 · 第 {page}/{totalPages} 頁",
+        "history.loadFailed": "載入工作流程失敗：{error}",
+        "history.cleanup.confirm": "清理策略：保留 {keepDays} 天 或 最新 {keepLatest} 筆工作流程，確定執行？",
+        "history.cleanup.failed": "清理失敗",
+        "history.cleanup.success": "清理完成：刪除 {count} 筆工作流程。",
+        "pipeline.done": "完成",
+        "status.pending": "待處理",
+        "status.running": "執行中",
+        "status.paused": "已暫停",
+        "status.completed": "完成",
+        "status.failed": "失敗",
+        "status.skipped": "略過",
+        "status.cancelled": "已取消",
+        "agent.retry": "重試 {count}",
+        "agent.tokens.in": "輸入: {value}",
+        "agent.tokens.out": "輸出: {value}",
+        "agent.output.none": "尚無輸出",
+        "agent.activity.thinking": "思考中...",
+        "agent.activity.toolUse": "使用 {tool} 中...",
+        "agent.activity.writing": "撰寫回應中...",
+        "agent.activity.waiting": "等待輸出中...",
+        "events.title": "事件記錄",
+        "events.count": "{count} 筆事件",
+        "events.connected": "已連線到伺服器",
+        "events.workflowStarted": "工作流程已開始：{title}",
+        "events.workflowCompleted": "工作流程已成功完成",
+        "events.workflowFailed": "工作流程失敗：{error}",
+        "events.workflowPaused": "工作流程已暫停",
+        "events.workflowCancelled": "工作流程已取消",
+        "events.agentStarted": "{agent} 代理已開始{retry}",
+        "events.agentCompleted": "{agent} 代理已於 {seconds}s 完成",
+        "events.agentFailed": "{agent} 代理失敗：{error}",
+        "events.agentRetry": "{agent} 代理重試中（{attempt}/{max}）：{reason}",
+        "events.retrySuffix": "（重試 {count}）",
+        "usage.loadingAria": "載入使用量資料中",
+        "usage.unavailableAria": "使用量資料不可用",
+        "usage.unavailable": "使用量: --",
+        "usage.session": "本次",
+        "usage.week": "本週",
+        "usage.sonnet": "Sonnet",
+        "usage.tooltip.session": "目前會話（5 小時視窗）",
+        "usage.tooltip.week": "全模型週使用量（7 天）",
+        "usage.tooltip.sonnet": "Sonnet 週使用量（7 天）",
+        "usage.tooltip.usage": "使用率: {value}",
+        "usage.tooltip.resets": "重置: {value}",
+        "usage.tooltip.na": "無",
+        "terminal.title": "終端機",
+        "terminal.connecting": "連線到伺服器中...",
+        "terminal.connected": "已連線",
+        "terminal.initializing": "初始化中...",
+        "terminal.error": "錯誤",
+        "historyDetail.title": "工作流程詳情",
+        "historyDetail.back": "← 返回歷史",
+        "historyDetail.loading": "載入中...",
+        "historyDetail.loadFailed": "載入失敗：{error}",
+        "historyDetail.meta.title": "標題：",
+        "historyDetail.meta.status": "狀態：",
+        "historyDetail.meta.created": "建立時間：",
+        "historyDetail.meta.completed": "完成時間：",
+        "historyDetail.retryWorkflow": "重試整個工作流程（新執行）",
+        "historyDetail.artifacts.title": "執行產物摘要（偵測到的檔案路徑）",
+        "historyDetail.artifacts.empty": "未從代理輸出偵測到檔案路徑。",
+        "historyDetail.step.retry": "從此步驟重試（新執行）",
+        "historyDetail.step.noOutput": "（無輸出）",
+        "historyDetail.step.in": "輸入",
+        "historyDetail.step.out": "輸出",
+    },
+};

package/dist/src/lib/i18n/useI18n.js

@@ -0,0 +1,20 @@
+"use client";
+import { useCallback } from "react";
+import { useI18nStore } from "@/stores/i18nStore";
+import { DEFAULT_LOCALE, messages } from "@/lib/i18n/messages";
+function interpolate(template, vars) {
+    if (!vars)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (_, key) => { var _a; return String((_a = vars[key]) !== null && _a !== void 0 ? _a : `{${key}}`); });
+}
+export function useI18n() {
+    var _a;
+    const locale = useI18nStore((s) => s.locale);
+    const dict = (_a = messages[locale]) !== null && _a !== void 0 ? _a : messages[DEFAULT_LOCALE];
+    const t = useCallback((key, vars) => {
+        var _a, _b;
+        const raw = (_b = (_a = dict[key]) !== null && _a !== void 0 ? _a : messages[DEFAULT_LOCALE][key]) !== null && _b !== void 0 ? _b : key;
+        return interpolate(raw, vars);
+    }, [dict]);
+    return { locale, t };
+}

package/dist/src/lib/terminal/pty-manager.js

@@ -34,6 +34,7 @@ function getShellPath() {
         return preferred;
     return '/bin/sh';
 }
+const MAX_REPLAY_BUFFER = 200000;
 export class PtyManager {
     constructor() {
         this.sessions = new Map();
@@ -51,15 +52,27 @@ export class PtyManager {
             cwd,
             env: Object.assign({}, process.env),
         });
+        const session = { id, process: proc, onData, buffer: '' };
         proc.onData((data) => {
-            onData(data);
+            session.buffer += data;
+            if (session.buffer.length > MAX_REPLAY_BUFFER) {
+                session.buffer = session.buffer.slice(session.buffer.length - MAX_REPLAY_BUFFER);
+            }
+            session.onData(data);
         });
         proc.onExit(() => {
             this.sessions.delete(id);
         });
-        this.sessions.set(id, { id, process: proc, onData });
+        this.sessions.set(id, session);
         return id;
     }
+    attach(id, onData) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return { ok: false };
+        session.onData = onData;
+        return { ok: true, replay: session.buffer };
+    }
     write(id, data) {
         const session = this.sessions.get(id);
         if (session) {

package/dist/src/lib/websocket/server.js

@@ -1,9 +1,10 @@
+import { normalizeExecutionPlan } from "../workflow/types.js";
 export function setupWebSocketHandlers(wss, connectionManager, engine, ptyManager, projectPath) {
     // Wire workflow engine events to WebSocket broadcasts
-    engine.on('workflow:created', (workflowId, title) => {
+    engine.on('workflow:created', (workflowId, title, executionPlan) => {
         connectionManager.broadcastAll({
             type: 'workflow:created',
-            payload: { workflowId, title },
+            payload: { workflowId, title, executionPlan },
         });
     });
     engine.on('workflow:completed', (workflowId) => {
@@ -94,7 +95,7 @@ function handleClientMessage(clientId, ws, msg, connectionManager, engine, ptyMa
             ws.send(JSON.stringify({ type: 'pong' }));
             break;
         case 'workflow:start': {
-            const { prompt, projectPath } = msg.payload || {};
+            const { prompt, projectPath, executionPlan } = msg.payload || {};
             if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
                 ws.send(JSON.stringify({
                     type: 'workflow:failed',
@@ -103,7 +104,8 @@ function handleClientMessage(clientId, ws, msg, connectionManager, engine, ptyMa
                 break;
             }
             const path = projectPath || defaultProjectPath;
-            engine.startWorkflow(prompt, path).then((workflowId) => {
+            const normalizedPlan = normalizeExecutionPlan(Array.isArray(executionPlan) ? executionPlan : undefined);
+            engine.startWorkflow(prompt, path, normalizedPlan).then((workflowId) => {
                 connectionManager.subscribeToWorkflow(clientId, workflowId);
             }).catch((err) => {
                 console.error('[WS] Failed to start workflow:', err);
@@ -163,6 +165,40 @@ function handleClientMessage(clientId, ws, msg, connectionManager, engine, ptyMa
             }
             break;
         }
+        case 'terminal:attach': {
+            const { terminalId, refresh } = msg.payload || {};
+            if (!terminalId)
+                break;
+            const result = ptyManager.attach(terminalId, (data) => {
+                connectionManager.sendTo(clientId, {
+                    type: 'terminal:output',
+                    payload: { terminalId, data },
+                });
+            });
+            if (result.ok) {
+                connectionManager.sendTo(clientId, {
+                    type: 'terminal:created',
+                    payload: { terminalId },
+                });
+                if (result.replay) {
+                    connectionManager.sendTo(clientId, {
+                        type: 'terminal:output',
+                        payload: { terminalId, data: result.replay },
+                    });
+                }
+                if (refresh) {
+                    // Trigger a full-screen redraw for TUI apps (e.g. htop) after reattach.
+                    ptyManager.write(terminalId, '\x0c');
+                }
+            }
+            else {
+                connectionManager.sendTo(clientId, {
+                    type: 'terminal:error',
+                    payload: { error: 'Terminal session not found; create a new one.' },
+                });
+            }
+            break;
+        }
         case 'terminal:input': {
             const { terminalId, data } = msg.payload || {};
             if (terminalId && data != null) {

package/dist/src/lib/workflow/engine.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import { v4 as uuidv4 } from 'uuid';
-import { AGENT_CONFIG, PIPELINE_STAGES, getStageForRole } from "./types.js";
+import { AGENT_CONFIG, PIPELINE_STAGES, getStageForRole, normalizeExecutionPlan } from "./types.js";
 import { createPipelineState } from "./pipeline.js";
 import { AgentRunner } from "./agent-runner.js";
 import { buildAgentPrompt } from "./context-builder.js";
@@ -17,11 +17,12 @@ export class WorkflowEngine extends EventEmitter {
         this.paused = new Set();
         this.dbOps = dbOps;
     }
-    async startWorkflow(userPrompt, projectPath) {
+    async startWorkflow(userPrompt, projectPath, executionPlan) {
         const workflowId = uuidv4();
         const title = userPrompt.slice(0, 80) + (userPrompt.length > 80 ? '...' : '');
-        this.dbOps.createWorkflow(workflowId, title, userPrompt, projectPath);
-        const pipeline = createPipelineState(workflowId);
+        const normalizedPlan = normalizeExecutionPlan(executionPlan);
+        this.dbOps.createWorkflow(workflowId, title, userPrompt, projectPath, normalizedPlan);
+        const pipeline = createPipelineState(workflowId, normalizedPlan);
         pipeline.status = 'running';
         this.pipelines.set(workflowId, pipeline);
         this.stepOutputs.set(workflowId, new Map());
@@ -33,20 +34,25 @@ export class WorkflowEngine extends EventEmitter {
         }
         this.stepIds.set(workflowId, stepIdMap);
         this.dbOps.updateWorkflowStatus(workflowId, 'running');
-        this.emit('workflow:created', workflowId, title);
+        this.emit('workflow:created', workflowId, title, normalizedPlan);
         // Defer to macrotask so callers can subscribe (microtask) before first step:started fires
         setTimeout(() => {
-            this.executePipeline(workflowId, userPrompt, projectPath).catch((err) => {
+            this.executePipeline(workflowId, userPrompt, projectPath, normalizedPlan).catch((err) => {
                 console.error(`Workflow ${workflowId} failed:`, err);
             });
         }, 0);
         return workflowId;
     }
-    async executePipeline(workflowId, userPrompt, projectPath) {
+    async executePipeline(workflowId, userPrompt, projectPath, executionPlan) {
         const pipeline = this.pipelines.get(workflowId);
         if (!pipeline)
             return;
+        const selected = new Set(executionPlan);
         for (const stage of PIPELINE_STAGES) {
+            const stageRoles = stage.roles.filter((role) => selected.has(role));
+            if (stageRoles.length === 0) {
+                continue;
+            }
             // Check if cancelled
             if (pipeline.status === 'cancelled') {
                 this.cleanupWorkflow(workflowId);
@@ -63,12 +69,12 @@ export class WorkflowEngine extends EventEmitter {
             pipeline.currentStageIndex = stage.index;
             this.dbOps.updateWorkflowStatus(workflowId, 'running', stage.index);
             // Execute all roles in this stage in parallel
-            const results = await Promise.allSettled(stage.roles.map(role => this.executeStep(workflowId, role, userPrompt, projectPath)));
+            const results = await Promise.allSettled(stageRoles.map(role => this.executeStep(workflowId, role, userPrompt, projectPath)));
             // Check for failures after all peers finish
             const failedRoles = [];
             for (let i = 0; i < results.length; i++) {
                 const result = results[i];
-                const role = stage.roles[i];
+                const role = stageRoles[i];
                 const stepState = pipeline.steps.find(s => s.role === role);
                 if (result.status === 'fulfilled' && result.value) {
                     if (stepState)

package/dist/src/lib/workflow/pipeline.js

@@ -1,12 +1,13 @@
-import { AGENT_ORDER } from "./types.js";
-export function createPipelineState(workflowId) {
+import { AGENT_ORDER, normalizeExecutionPlan } from "./types.js";
+export function createPipelineState(workflowId, executionPlan) {
+    const selected = new Set(normalizeExecutionPlan(executionPlan));
     return {
         workflowId,
         status: 'pending',
         currentStageIndex: 0,
         steps: AGENT_ORDER.map((role) => ({
             role,
-            status: 'pending',
+            status: selected.has(role) ? 'pending' : 'skipped',
             retryCount: 0,
         })),
     };

package/dist/src/lib/workflow/types.js

@@ -1,3 +1,4 @@
+export const ALL_AGENT_ROLES = ['pm', 'rd', 'ui', 'test', 'sec'];
 export const PIPELINE_STAGES = [
     { index: 0, roles: ['pm'] },
     { index: 1, roles: ['rd', 'ui'] },
@@ -5,6 +6,18 @@ export const PIPELINE_STAGES = [
 ];
 /** The fixed execution order for agents within a workflow (derived from stages). */
 export const AGENT_ORDER = PIPELINE_STAGES.flatMap(s => s.roles);
+export function normalizeExecutionPlan(input) {
+    if (!input || input.length === 0)
+        return [...AGENT_ORDER];
+    const requested = new Set();
+    for (const role of input) {
+        if (AGENT_ORDER.includes(role)) {
+            requested.add(role);
+        }
+    }
+    const ordered = AGENT_ORDER.filter((role) => requested.has(role));
+    return ordered.length > 0 ? ordered : [...AGENT_ORDER];
+}
 /** Get the pipeline stage that contains the given role. */
 export function getStageForRole(role) {
     const stage = PIPELINE_STAGES.find(s => s.roles.includes(role));