@plainconceptsplatform/loop-task 2.6.0

package/dist/features/chain-editor/renderChainDiagram.js

@@ -0,0 +1,106 @@
+import { commandLine } from "../../shared/ui/format.js";
+/**
+ * Render a task chain as ASCII art, starting from a root task.
+ * Handles cycles (shows "(cycle to TaskName)"), missing tasks
+ * (shows "(missing task)"), and silent chain markers ("[s]").
+ */
+export function renderChainDiagram(rootTaskId, tasks) {
+    const taskMap = new Map();
+    for (const task of tasks) {
+        taskMap.set(task.id, task);
+    }
+    const rootTask = taskMap.get(rootTaskId);
+    if (!rootTask) {
+        return renderMissingTaskBox(rootTaskId);
+    }
+    const visited = new Set();
+    function renderTask(task, _branch) {
+        if (visited.has(task.id)) {
+            const name = task.name || task.id;
+            return `(cycle to ${name})`;
+        }
+        visited.add(task.id);
+        const lines = [];
+        const silent = task.silentChain ? " [s]" : "";
+        // Name line
+        lines.push(`${task.name}${silent}`);
+        // Steps or command
+        if (task.steps && task.steps.length > 0) {
+            for (let i = 0; i < task.steps.length; i++) {
+                const step = task.steps[i];
+                for (const cmd of step.commands) {
+                    lines.push(`  Step ${i + 1}: ${commandLine(cmd.command, cmd.commandArgs)}`);
+                }
+            }
+        }
+        else {
+            lines.push(`  ${commandLine(task.command, task.commandArgs)}`);
+        }
+        // Branch annotations
+        const successTarget = task.onSuccessTaskId
+            ? resolveBranchLabel(task.onSuccessTaskId, taskMap, visited)
+            : "(none)";
+        const failureTarget = task.onFailureTaskId
+            ? resolveBranchLabel(task.onFailureTaskId, taskMap, visited)
+            : "(none)";
+        lines.push(`  onSuccess -> ${successTarget}`);
+        lines.push(`  onFailure -> ${failureTarget}`);
+        // Build box
+        const box = renderBox(lines);
+        // Recurse into children that haven't been visited yet
+        const children = [];
+        if (task.onSuccessTaskId) {
+            const child = taskMap.get(task.onSuccessTaskId);
+            if (child && !visited.has(child.id)) {
+                children.push(renderTask(child, "success"));
+            }
+        }
+        if (task.onFailureTaskId) {
+            const child = taskMap.get(task.onFailureTaskId);
+            if (child && !visited.has(child.id)) {
+                children.push(renderTask(child, "failure"));
+            }
+        }
+        if (children.length > 0) {
+            return box + "\n" + children.map((c) => connector() + "\n" + c).join("\n");
+        }
+        return box;
+    }
+    const result = renderTask(rootTask, null);
+    return result;
+}
+function resolveBranchLabel(targetId, taskMap, visited) {
+    const target = taskMap.get(targetId);
+    if (!target)
+        return `${targetId} (missing task)`;
+    if (visited.has(targetId))
+        return `${target.name || targetId} (cycle)`;
+    const silent = target.silentChain ? " (silent)" : "";
+    return `${target.name || targetId}${silent}`;
+}
+function renderBox(lines) {
+    const maxWidth = Math.max(3, ...lines.map((l) => stripAnsi(l).length)) + 4;
+    const border = "+" + "-".repeat(maxWidth) + "+";
+    const boxed = [border];
+    for (const line of lines) {
+        const displayLen = stripAnsi(line).length;
+        const padding = maxWidth - displayLen - 2;
+        boxed.push(`|  ${line}${" ".repeat(Math.max(0, padding))}  |`);
+    }
+    boxed.push(border);
+    return boxed.join("\n");
+}
+function renderMissingTaskBox(taskId) {
+    const lines = [taskId, "  (missing task)"];
+    return renderBox(lines);
+}
+function connector() {
+    return "               |               \n               v";
+}
+/**
+ * Strip ANSI escape codes for length calculation.
+ * Safe no-op for plain strings.
+ */
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}

package/dist/features/code-editor/CodeEditorModal.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState, useCallback, useMemo } from "react";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { useUndoRedo } from "../../shared/hooks/useUndoRedo.js";
+import { highlightSegments } from "../../shared/utils/syntax.js";
+import { joinCommandLines } from "../../loop-config.js";
+import { CODE_EDITOR_UNDO_LIMIT, CODE_EDITOR_SYNTAX_COLORS } from "../../shared/config/constants.js";
+import { useModalDimensions } from "./useModalDimensions.js";
+import { useEditorKeyboard } from "./useEditorKeyboard.js";
+export function CodeEditorModal(props) {
+    const { initialValue, onSave, onCancel } = props;
+    const { modalWidth, modalHeight, editorVisibleLines: EDITOR_VISIBLE_LINES } = useModalDimensions();
+    const { value, setValue, undo, redo } = useUndoRedo(initialValue, CODE_EDITOR_UNDO_LIMIT);
+    const [cursorRow, setCursorRow] = useState(() => {
+        const lines = initialValue.split("\n");
+        return Math.max(0, lines.length - 1);
+    });
+    const [cursorCol, setCursorCol] = useState(() => {
+        const lines = initialValue.split("\n");
+        return (lines[lines.length - 1] ?? "").length;
+    });
+    const [flashMsg, setFlashMsg] = useState(null);
+    const lines = useMemo(() => (value ? value.split("\n") : [""]), [value]);
+    const lineCount = lines.length;
+    const lineNumWidth = String(lineCount).length;
+    React.useEffect(() => {
+        if (flashMsg) {
+            const timer = setTimeout(() => setFlashMsg(null), 1500);
+            return () => clearTimeout(timer);
+        }
+    }, [flashMsg]);
+    const scrollStart = useMemo(() => {
+        if (cursorRow < EDITOR_VISIBLE_LINES)
+            return 0;
+        return cursorRow - EDITOR_VISIBLE_LINES + 1;
+    }, [cursorRow]);
+    const visibleLines = useMemo(() => lines.slice(scrollStart, scrollStart + EDITOR_VISIBLE_LINES), [lines, scrollStart]);
+    const applyMutation = useCallback((nextLines, newCursorRow, newCursorCol) => {
+        setValue(nextLines.join("\n"));
+        setCursorRow(newCursorRow);
+        setCursorCol(newCursorCol);
+    }, [setValue]);
+    useEditorKeyboard({
+        lines,
+        cursorRow,
+        cursorCol,
+        value,
+        setValue,
+        setCursorRow,
+        setCursorCol,
+        undo,
+        redo,
+        onSave,
+        onCancel,
+        setFlashMsg,
+        applyMutation,
+    });
+    const joined = joinCommandLines(value);
+    const innerWidth = modalWidth - 2;
+    const truncatedPreview = joined.length > innerWidth
+        ? joined.slice(0, innerWidth - 1) + t("codeEditor.previewTruncated")
+        : joined;
+    const accent = theme.accent.brand;
+    return (_jsx(Box, { position: "absolute", top: 0, left: 0, width: "100%", height: "100%", justifyContent: "center", alignItems: "center", children: _jsxs(Box, { width: modalWidth, height: modalHeight, flexDirection: "column", backgroundColor: theme.bg.elevated, borderStyle: "round", borderColor: accent, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: accent, bold: true, children: t("codeEditor.title") }), _jsxs(Text, { color: theme.text.muted, children: [lineCount, " ", t("cmdEditor.lines")] })] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleLines.map((line, visIdx) => {
+                        const rowIdx = scrollStart + visIdx;
+                        const isCursor = rowIdx === cursorRow;
+                        const lineNum = String(rowIdx + 1).padStart(lineNumWidth, " ");
+                        if (isCursor) {
+                            const before = line.slice(0, cursorCol);
+                            const cur = cursorCol < line.length ? line[cursorCol] : " ";
+                            const after = cursorCol < line.length ? line.slice(cursorCol + 1) : "";
+                            // Cursor line: render with cursor (no syntax highlight on cursor line)
+                            return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), _jsx(Text, { color: theme.text.primary, children: before }), _jsx(Text, { inverse: true, children: cur }), _jsx(Text, { color: theme.text.primary, children: after })] }, rowIdx));
+                        }
+                        // Non-cursor line: syntax highlighted (whitespace preserved)
+                        const segments = highlightSegments(line, CODE_EDITOR_SYNTAX_COLORS, theme.text.muted);
+                        if (segments.length === 0) {
+                            return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), _jsx(Text, { children: " " })] }, rowIdx));
+                        }
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), segments.map((seg, ti) => (_jsx(Text, { color: seg.color, children: seg.value }, ti)))] }, rowIdx));
+                    }) }), _jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [t("codeEditor.previewLabel"), " "] }), _jsx(Text, { color: theme.text.secondary, children: truncatedPreview || t("codeEditor.emptyPlaceholder") })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonCopy") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+x" }), _jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonPaste") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+v" }), _jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonClear") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+l" })] }), flashMsg ? (_jsx(Text, { color: theme.semantic.success, children: flashMsg })) : null] }), _jsx(Box, { children: _jsx(Text, { color: theme.text.muted, children: t("codeEditor.hint") }) })] }) }));
+}

package/dist/features/code-editor/CodeEditorPreview.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { CODE_EDITOR_MAX_VISIBLE } from "../../shared/config/constants.js";
+export function CodeEditorPreview(props) {
+    const { value, hint, isActive, onActivate } = props;
+    const lines = value ? value.split("\n") : [];
+    const visibleLines = lines.slice(0, CODE_EDITOR_MAX_VISIBLE);
+    const truncated = lines.length > CODE_EDITOR_MAX_VISIBLE;
+    const hasValue = lines.length > 0;
+    void onActivate; // consumed by parent via useInput when active
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Box, { borderStyle: "single", borderColor: isActive ? theme.accent.brand : theme.border.dim, backgroundColor: isActive ? theme.bg.input : undefined, paddingLeft: 1, overflow: "hidden", width: "100%", flexDirection: "column", children: hasValue ? (_jsxs(_Fragment, { children: [visibleLines.map((line, i) => (_jsx(Text, { color: theme.text.primary, children: line }, i))), truncated ? (_jsx(Text, { color: theme.text.muted, children: t("codeEditor.previewTruncated") })) : null] })) : (_jsx(Text, { color: theme.text.muted, children: hint })) }), isActive ? (_jsxs(Box, { marginTop: 0, children: [_jsx(Text, { color: theme.accent.brand, children: "› " }), _jsx(Text, { color: theme.text.muted, children: t("codeEditor.fieldHint") })] })) : null] }));
+}

package/dist/features/code-editor/useEditorKeyboard.js

@@ -0,0 +1,150 @@
+import { useInput } from "ink";
+import { t } from "../../shared/i18n/index.js";
+import { copyToClipboard, readFromClipboard } from "../../shared/clipboard.js";
+import { sanitizeMultilinePaste, wrapCommand } from "../../shared/utils/paste.js";
+export function useEditorKeyboard(params) {
+    const { lines, cursorRow, cursorCol, value, setValue, setCursorRow, setCursorCol, undo, redo, onSave, onCancel, setFlashMsg, applyMutation, } = params;
+    useInput((input, key) => {
+        if (input.includes("\x1b[200~")) {
+            const pasted = wrapCommand(sanitizeMultilinePaste(input));
+            if (pasted) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol + pasted.length);
+            }
+            return;
+        }
+        // Swallow SGR mouse sequences
+        if (input.includes("[<"))
+            return;
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if ((key.ctrl && input === "s") || input === "\x13") {
+            onSave(value);
+            return;
+        }
+        if ((key.ctrl && !key.shift && input === "z") || input === "\x1a") {
+            undo();
+            return;
+        }
+        if (key.ctrl && key.shift && input === "z") {
+            redo();
+            return;
+        }
+        if ((key.ctrl && input === "x") || input === "\x18") {
+            copyToClipboard(value);
+            setValue("");
+            setCursorRow(0);
+            setCursorCol(0);
+            setFlashMsg(t("codeEditor.copied"));
+            return;
+        }
+        if ((key.ctrl && input === "v") || input === "\x16") {
+            const clip = readFromClipboard();
+            if (clip) {
+                const pasted = sanitizeMultilinePaste(clip);
+                if (pasted) {
+                    const next = [...lines];
+                    const line = next[cursorRow] ?? "";
+                    next[cursorRow] =
+                        line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                    applyMutation(next, cursorRow, cursorCol + pasted.length);
+                }
+            }
+            else {
+                setFlashMsg(t("codeEditor.clipboardEmpty"));
+            }
+            return;
+        }
+        if ((key.ctrl && input === "l") || input === "\x0c") {
+            setValue("");
+            setCursorRow(0);
+            setCursorCol(0);
+            setFlashMsg(t("codeEditor.cleared"));
+            return;
+        }
+        if (key.return) {
+            const next = [...lines];
+            const line = next[cursorRow] ?? "";
+            next.splice(cursorRow, 1, line.slice(0, cursorCol), line.slice(cursorCol));
+            applyMutation(next, cursorRow + 1, 0);
+            return;
+        }
+        if (key.upArrow) {
+            if (cursorRow > 0) {
+                const newRow = cursorRow - 1;
+                setCursorRow(newRow);
+                setCursorCol((c) => Math.min(c, (lines[newRow] ?? "").length));
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (cursorRow < lines.length - 1) {
+                const newRow = cursorRow + 1;
+                setCursorRow(newRow);
+                setCursorCol((c) => Math.min(c, (lines[newRow] ?? "").length));
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            if (cursorCol > 0) {
+                setCursorCol((c) => c - 1);
+            }
+            else if (cursorRow > 0) {
+                setCursorRow((r) => r - 1);
+                setCursorCol((lines[cursorRow - 1] ?? "").length);
+            }
+            return;
+        }
+        if (key.rightArrow) {
+            const curLen = (lines[cursorRow] ?? "").length;
+            if (cursorCol < curLen) {
+                setCursorCol((c) => c + 1);
+            }
+            else if (cursorRow < lines.length - 1) {
+                setCursorRow((r) => r + 1);
+                setCursorCol(0);
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursorCol > 0) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol - 1) + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol - 1);
+            }
+            else if (cursorRow > 0) {
+                const next = [...lines];
+                const prev = next[cursorRow - 1] ?? "";
+                const cur = next[cursorRow] ?? "";
+                next.splice(cursorRow - 1, 2, prev + cur);
+                applyMutation(next, cursorRow - 1, prev.length);
+            }
+            return;
+        }
+        if (input.length > 1 && !key.meta) {
+            const pasted = wrapCommand(sanitizeMultilinePaste(input));
+            if (pasted) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol + pasted.length);
+            }
+            return;
+        }
+        if (input.length === 1 && input >= " " && input <= "~") {
+            const next = [...lines];
+            const line = next[cursorRow] ?? "";
+            next[cursorRow] =
+                line.slice(0, cursorCol) + input + line.slice(cursorCol);
+            applyMutation(next, cursorRow, cursorCol + 1);
+        }
+    }, { isActive: true });
+}

package/dist/features/code-editor/useModalDimensions.js

@@ -0,0 +1,9 @@
+import { CODE_EDITOR_MODAL_HEIGHT, CODE_EDITOR_MODAL_WIDTH, } from "../../shared/config/constants.js";
+export function useModalDimensions() {
+    const termRows = process.stdout.rows || 24;
+    const termCols = process.stdout.columns || 80;
+    const modalHeight = Math.min(CODE_EDITOR_MODAL_HEIGHT, termRows - 2);
+    const modalWidth = Math.min(CODE_EDITOR_MODAL_WIDTH, termCols - 2);
+    const editorVisibleLines = Math.max(3, modalHeight - 6);
+    return { modalWidth, modalHeight, editorVisibleLines };
+}

package/dist/features/commands/commands.js

@@ -0,0 +1,132 @@
+import { COMMAND_TIER_ACTION, COMMAND_TIER_CONFIRM, COMMAND_TIER_GLOBAL, COMMAND_CATEGORY_GLOBAL, COMMAND_CATEGORY_FILTERS, COMMAND_CATEGORY_LOOP, COMMAND_CATEGORY_TASK, COMMAND_CATEGORY_PROJECT, } from '../../shared/config/constants.js';
+import { t } from '../../shared/i18n/index.js';
+function globalCommands() {
+    return [
+        { label: t('cmd.help'), value: 'help', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+p' },
+        { label: t('cmd.debug'), value: 'debug', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+b' },
+        { label: t('cmd.toggleApi'), value: 'toggle-api', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.api'), value: 'api', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.toggleMcp'), value: 'toggle-mcp', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.mcp'), value: 'mcp', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.toggleTelemetry'), value: 'toggle-telemetry', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.telemetryDiagnostics'), value: 'telemetry-diagnostics', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.telemetry'), value: 'telemetry', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.export'), value: 'export', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+x' },
+        { label: t('cmd.import'), value: 'import', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+i' },
+    ];
+}
+function loopFilterCommands() {
+    return [
+        { label: t('cmd.search'), value: 'search', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+s' },
+        { label: t('cmd.filterStatus'), value: 'filter-status', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+t' },
+        { label: t('cmd.sort'), value: 'sort', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+o' },
+        { label: t('cmd.project'), value: 'filter-project', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+p' },
+    ];
+}
+function taskFilterCommands() {
+    return [
+        { label: t('cmd.searchTasks'), value: 'search', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+s' },
+    ];
+}
+function projectFilterCommands() {
+    return [
+        { label: t('cmd.searchProjects'), value: 'search', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_FILTERS, shortcut: 'ctrl+f+s' },
+    ];
+}
+/**
+ * Re-rank autocomplete options: exact match → prefix match → fuzzy (existing order).
+ * Stable within each group. Exported for testing.
+ */
+export function rankCommands(input, options) {
+    if (input.length === 0)
+        return options;
+    const q = input.toLowerCase();
+    const exact = [];
+    const prefix = [];
+    const fuzzy = [];
+    for (const opt of options) {
+        const l = opt.label.toLowerCase();
+        const v = opt.value.toLowerCase();
+        if (l === q || v === q) {
+            exact.push(opt);
+        }
+        else if (l.startsWith(q) || v.startsWith(q)) {
+            prefix.push(opt);
+        }
+        else {
+            fuzzy.push(opt);
+        }
+    }
+    return [...exact, ...prefix, ...fuzzy];
+}
+export function buildCommands(context) {
+    const commands = [...globalCommands()];
+    if (context.activeTab === 'loops') {
+        commands.push(...loopFilterCommands());
+        commands.push({
+            label: t('cmd.newLoop'), value: 'new-loop', hint: '',
+            tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+n',
+        });
+        if (context.selectedLoop !== null) {
+            const loop = context.selectedLoop;
+            const desc = loop.description || loop.id;
+            commands.push({ label: t('cmd.edit'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+e' }, { label: t('cmd.pause'), value: 'pause', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+p' }, { label: t('cmd.play'), value: 'play', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+r' }, { label: t('cmd.stop'), value: 'stop', hint: t('confirm.stopLoop', { name: desc }), tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+s' }, { label: t('cmd.trigger'), value: 'trigger', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+t' }, { label: t('cmd.clone'), value: 'clone', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+c' }, { label: t('cmd.delete'), value: 'delete', hint: t('confirm.deleteLoop', { name: desc }), tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+d' }, { label: t('cmd.logs'), value: 'logs', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+o' });
+            if (loop.taskId && loop.isRecipe) {
+                commands.push({
+                    label: t('cmd.diagram'), value: 'diagram', hint: '',
+                    tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP,
+                });
+            }
+        }
+    }
+    if (context.activeTab === 'tasks') {
+        commands.push(...taskFilterCommands());
+        commands.push({
+            label: t('cmd.newTask'), value: 'new-task', hint: '',
+            tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+n',
+        });
+        if (context.selectedTask !== null) {
+            const task = context.selectedTask;
+            commands.push({ label: t('cmd.editTask'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+e' }, { label: t('cmd.deleteTask'), value: 'delete', hint: t('confirm.deleteTask', { id: task.id }), tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+d' });
+            if (task.isRecipeTask) {
+                // Remove edit and delete for recipe tasks — they are immutable
+                commands.pop();
+                commands.pop();
+            }
+        }
+    }
+    if (context.activeTab === 'projects') {
+        commands.push(...projectFilterCommands());
+        commands.push({
+            label: t('cmd.newProject'), value: 'new-project', hint: '',
+            tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+n',
+        });
+        if (context.selectedProject !== null) {
+            const project = context.selectedProject;
+            commands.push({ label: t('cmd.editProject'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+e' }, { label: t('cmd.deleteProject'), value: 'delete', hint: t('confirm.deleteProject', { name: project.name }), tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+d' });
+        }
+    }
+    return commands;
+}
+export function buildTabCommands(context) {
+    const commands = [...globalCommands()];
+    if (context.activeTab === 'loops') {
+        commands.push(...loopFilterCommands());
+        commands.push({ label: t('cmd.newLoop'), value: 'new-loop', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+n' }, { label: t('cmd.edit'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+e' }, { label: t('cmd.pause'), value: 'pause', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+p' }, { label: t('cmd.play'), value: 'play', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+r' }, { label: t('cmd.stop'), value: 'stop', hint: '', tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+s' }, { label: t('cmd.trigger'), value: 'trigger', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+t' }, { label: t('cmd.clone'), value: 'clone', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+c' }, { label: t('cmd.delete'), value: 'delete', hint: '', tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+d' }, { label: t('cmd.logs'), value: 'logs', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP, shortcut: 'ctrl+a+o' });
+        if (context.selectedLoop?.taskId && context.selectedLoop?.isRecipe) {
+            commands.push({
+                label: t('cmd.diagram'), value: 'diagram', hint: '',
+                tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_LOOP,
+            });
+        }
+    }
+    if (context.activeTab === 'tasks') {
+        commands.push(...taskFilterCommands());
+        commands.push({ label: t('cmd.newTask'), value: 'new-task', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+n' }, { label: t('cmd.editTask'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+e' }, { label: t('cmd.deleteTask'), value: 'delete', hint: '', tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_TASK, shortcut: 'ctrl+a+d' });
+    }
+    if (context.activeTab === 'projects') {
+        commands.push(...projectFilterCommands());
+        commands.push({ label: t('cmd.newProject'), value: 'new-project', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+n' }, { label: t('cmd.editProject'), value: 'edit', hint: '', tier: COMMAND_TIER_ACTION, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+e' }, { label: t('cmd.deleteProject'), value: 'delete', hint: '', tier: COMMAND_TIER_CONFIRM, category: COMMAND_CATEGORY_PROJECT, shortcut: 'ctrl+a+d' });
+    }
+    return commands;
+}