@plainconceptsplatform/loop-task 2.6.0

package/dist/features/commands/useCommandHandlers.js

@@ -0,0 +1,280 @@
+import { t } from "../../shared/i18n/index.js";
+import { cycleSortMode, cycleStatusFilter } from "../../entities/loops/filters.js";
+import { cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter } from "../../entities/projects/filters.js";
+import { groupRunsByCycle } from "../../widgets/right-panel/RunHistory.js";
+import { container } from "../../shared/container/index.js";
+import { TYPES } from "../../shared/services/types.js";
+import { readRecipeDiagram } from "../../daemon/recipe/diagram-reader.js";
+import { renderMermaidAsAscii } from "../chain-editor/mermaidToAscii.js";
+export function useCommandHandlers(context) {
+    const { activeTab, selected, selectedRunIndex, selectedTask, selectedProjectEntity, tasks, projects, currentProjectId, setCloneMode, setEditTarget, setPendingTaskSelection, setEditTask, setEditProject, setActiveTab, setConfirmState, setCommandsBrowserOpen, setSearchValue, setSearchState, setFilters, setSort, setCurrentProjectId, setProjectFilters, setProjectSelectedIndex, setDebugMode, setExportModal, setDiagramModal, push, pop, refresh, refreshTasks, refreshProjects, pushToast, loopService, taskService, projectService, exportService, runAction, handleOpenRunLog, } = context;
+    const commandHandlers = {
+        edit: () => {
+            if (activeTab === "loops" && selected) {
+                setCloneMode(false);
+                setEditTarget(selected);
+                if (selected.taskId) {
+                    const task = tasks.find((t) => t.id === selected.taskId);
+                    setPendingTaskSelection(task ? { id: task.id, name: task.name } : null);
+                }
+                else {
+                    setPendingTaskSelection(null);
+                }
+                push("create");
+            }
+            else if (activeTab === "tasks" && selectedTask) {
+                if (selectedTask.isRecipeTask) {
+                    pushToast("error", t("task.recipeImmutable"));
+                    return;
+                }
+                setEditTask(selectedTask);
+                push("task-edit");
+            }
+            else if (activeTab === "projects" && selectedProjectEntity && !selectedProjectEntity.isSystem) {
+                setEditProject(selectedProjectEntity);
+                push("project-edit");
+            }
+        },
+        clone: () => {
+            if (activeTab === "loops" && selected) {
+                setCloneMode(true);
+                setEditTarget(selected);
+                push("create");
+            }
+        },
+        delete: () => {
+            if (activeTab === "loops" && selected) {
+                setConfirmState({
+                    prompt: t("confirm.deleteLoop", { name: selected.description || selected.id }),
+                    onConfirm: () => { void loopService.delete(selected.id).then(() => { void refresh(); }); },
+                });
+            }
+            else if (activeTab === "tasks" && selectedTask) {
+                if (selectedTask.isRecipeTask) {
+                    pushToast("error", t("task.recipeImmutable"));
+                    return;
+                }
+                setConfirmState({
+                    prompt: t("confirm.deleteTask", { id: selectedTask.id }),
+                    onConfirm: () => { void taskService.delete(selectedTask.id).then(() => { void refreshTasks(); }); },
+                });
+            }
+            else if (activeTab === "projects" && selectedProjectEntity && !selectedProjectEntity.isSystem) {
+                setConfirmState({
+                    prompt: t("confirm.deleteProject", { name: selectedProjectEntity.name }),
+                    onConfirm: async () => {
+                        try {
+                            await projectService.delete(selectedProjectEntity.id);
+                            pushToast("success", t("project.toastDeleted", { name: selectedProjectEntity.name }));
+                            setProjectSelectedIndex(0);
+                            void refreshProjects();
+                        }
+                        catch (e) {
+                            pushToast("error", e.message);
+                        }
+                    },
+                });
+            }
+        },
+        pause: () => {
+            if (activeTab === "loops" && selected) {
+                void runAction(t("board.toastPaused", { desc: selected.description }), () => loopService.pause(selected.id))();
+            }
+        },
+        play: () => {
+            if (activeTab === "loops" && selected) {
+                const isPaused = selected.status === "paused";
+                const toastKey = isPaused ? "board.toastResumed" : "board.toastPlayed";
+                const fn = isPaused ? () => loopService.resume(selected.id) : () => loopService.play(selected.id);
+                void runAction(t(toastKey, { desc: selected.description }), fn)();
+            }
+        },
+        stop: () => {
+            if (activeTab === "loops" && selected) {
+                setConfirmState({
+                    prompt: t("confirm.stopLoop", { name: selected.description || selected.id }),
+                    onConfirm: () => { void loopService.stop(selected.id).then(() => { void refresh(); }); },
+                });
+            }
+        },
+        trigger: () => {
+            if (activeTab === "loops" && selected) {
+                void runAction(t("board.toastTriggered", { desc: selected.description }), () => loopService.trigger(selected.id))();
+            }
+        },
+        "new-loop": () => { setEditTarget(null); push("create"); },
+        "new-task": () => { setEditTask(null); push("task-create"); },
+        "new-project": () => { setEditProject(null); setActiveTab("projects"); push("project-create"); },
+        "project-filter-loops": () => { setProjectFilters((prev) => ({ ...prev, hasLoops: cycleProjectHasLoopsFilter(prev.hasLoops) })); },
+        "project-filter-type": () => { setProjectFilters((prev) => ({ ...prev, isSystem: cycleProjectIsSystemFilter(prev.isSystem) })); },
+        "project-sort": () => { setProjectFilters((prev) => ({ ...prev, sort: cycleProjectSortMode(prev.sort) })); },
+        "all-commands": () => { setCommandsBrowserOpen(true); },
+        help: () => { setCommandsBrowserOpen(true); },
+        search: () => { setSearchValue(""); setSearchState({ active: true }); },
+        "filter-status": () => { setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })); },
+        sort: () => { setSort((prev) => cycleSortMode(prev)); },
+        "filter-project": () => {
+            const ids = ["all", ...projects.map((p) => p.id)];
+            const idx = ids.indexOf(currentProjectId);
+            const nextId = ids[(idx + 1) % ids.length] ?? "all";
+            setCurrentProjectId(nextId);
+        },
+        debug: () => { setDebugMode((prev) => !prev); },
+        logs: () => {
+            if (activeTab === "loops" && selected) {
+                const reversed = [...groupRunsByCycle(selected.runHistory)].reverse();
+                if (reversed.length > 0) {
+                    const run = reversed[Math.min(selectedRunIndex, reversed.length - 1)];
+                    handleOpenRunLog(run ?? reversed[0]);
+                }
+            }
+        },
+        select: () => {
+            if (selectedTask) {
+                setPendingTaskSelection({ id: selectedTask.id, name: selectedTask.name });
+                pop();
+            }
+        },
+        api: () => {
+            const port = process.env.LOOP_CLI_HTTP_PORT ?? "8845";
+            const baseUrl = `http://127.0.0.1:${port}`;
+            pushToast("info", `API: ${baseUrl} | Swagger: ${baseUrl}/api/docs | OpenAPI: ${baseUrl}/api/openapi.json`);
+        },
+        "toggle-api": async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const current = await settingsService.getHttpApiEnabled();
+                await settingsService.setHttpApiEnabled(!current);
+                pushToast("success", t(!current ? "board.toastApiEnabled" : "board.toastApiDisabled"));
+            }
+            catch (e) {
+                pushToast("error", t("board.toastApiToggleError", { message: e.message }));
+            }
+        },
+        mcp: () => {
+            const transport = process.env.LOOP_CLI_MCP_TRANSPORT ?? "sse";
+            const port = process.env.LOOP_CLI_MCP_PORT ?? "8846";
+            const info = transport === "stdio"
+                ? `MCP server on stdio. To use SSE (default), restart without LOOP_CLI_MCP_TRANSPORT=stdio`
+                : `MCP: connect your client to http://127.0.0.1:${port}/sse`;
+            pushToast("info", info);
+        },
+        "toggle-mcp": async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const current = await settingsService.getMcpApiEnabled();
+                await settingsService.setMcpApiEnabled(!current);
+                pushToast("success", t(!current ? "board.toastMcpEnabled" : "board.toastMcpDisabled"));
+            }
+            catch (e) {
+                pushToast("error", t("board.toastMcpToggleError", { message: e.message }));
+            }
+        },
+        telemetry: async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const settings = await settingsService.getSettings();
+                const status = settings.telemetryEnabled ? t("telemetry.statusEnabled") : t("telemetry.statusDisabled");
+                const endpoint = settings.telemetryEndpoint ?? t("telemetry.exportNotConfigured");
+                const hasHeaders = !!(process.env.OTEL_EXPORTER_OTLP_HEADERS || process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS);
+                const agents = settings.telemetryAutoInstrumentAgents ? t("telemetry.statusEnabled") : t("telemetry.statusDisabled");
+                const capture = settings.telemetryCaptureContent ? t("telemetry.statusEnabled") : t("telemetry.statusDisabled");
+                const exportState = !settings.telemetryEnabled
+                    ? t("telemetry.statusDisabled")
+                    : !settings.telemetryEndpoint
+                        ? t("telemetry.exportNotConfigured")
+                        : t("telemetry.exportConfigured");
+                const info = [
+                    t("telemetry.infoEnabled", { status }),
+                    t("telemetry.infoExport", { state: exportState }),
+                    t("telemetry.infoEndpoint", { endpoint }),
+                    t("telemetry.infoProtocol", { protocol: settings.telemetryProtocol }),
+                    t("telemetry.infoAgents", { status: agents }),
+                    t("telemetry.infoCapture", { status: capture }),
+                    t("telemetry.infoHeaders", { status: hasHeaders ? "configured" : "not configured" }),
+                    t("telemetry.infoService", { name: settings.telemetryServiceName }),
+                ].join(" | ");
+                pushToast("info", info);
+            }
+            catch (e) {
+                pushToast("error", e.message);
+            }
+        },
+        "toggle-telemetry": async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const current = await settingsService.getTelemetryEnabled();
+                await settingsService.setTelemetryEnabled(!current);
+                if (!current && !(await settingsService.getSettings()).telemetryEndpoint) {
+                    pushToast("success", t("board.toastTelemetryNotConfigured"));
+                }
+                else {
+                    pushToast("success", t(!current ? "board.toastTelemetryEnabled" : "board.toastTelemetryDisabled"));
+                }
+            }
+            catch (e) {
+                pushToast("error", t("board.toastTelemetryToggleError", { message: e.message }));
+            }
+        },
+        "telemetry-diagnostics": async () => {
+            try {
+                const { sendRequest } = await import("../../client/ipc.js");
+                const res = await sendRequest({ type: "telemetry-test" });
+                if (res.type === "ok") {
+                    const result = res.data;
+                    if (result.success) {
+                        pushToast("success", t("board.toastTelemetryTestSucceeded", { endpoint: result.message }));
+                    }
+                    else {
+                        pushToast("error", t("board.toastTelemetryTestFailed", { message: result.message }));
+                    }
+                }
+                else {
+                    pushToast("error", t("board.toastTelemetryTestFailed", { message: "request failed" }));
+                }
+            }
+            catch (e) {
+                pushToast("error", t("board.toastTelemetryTestFailed", { message: e.message }));
+            }
+        },
+        diagram: () => {
+            if (activeTab === "loops" && selected?.taskId) {
+                if (selected.isRecipe && selected.recipeFilePath) {
+                    try {
+                        const diagram = readRecipeDiagram(selected.recipeFilePath);
+                        if (diagram) {
+                            // Render Mermaid as ASCII for the TUI modal
+                            const ascii = renderMermaidAsAscii(diagram);
+                            setDiagramModal(ascii);
+                        }
+                        else {
+                            pushToast("error", t("diagram.noDiagramInRecipe"));
+                        }
+                    }
+                    catch (e) {
+                        pushToast("error", t("diagram.readError", { message: e.message }));
+                    }
+                }
+                else {
+                    pushToast("error", t("diagram.notARecipe"));
+                }
+            }
+        },
+        export: () => {
+            exportService.exportConfig()
+                .then(({ json, filePath }) => setExportModal({ json, filePath, error: null }))
+                .catch((e) => setExportModal({ json: "", filePath: null, error: e instanceof Error ? e.message : String(e) }));
+        },
+        import: () => { pushToast("info", `Command "import" coming soon`); },
+    };
+    function handleCommand(value) {
+        const handler = commandHandlers[value];
+        if (handler) {
+            handler();
+        }
+        else {
+            pushToast("error", `Unknown command: ${value}`);
+        }
+    }
+    return { handlers: commandHandlers, handleCommand };
+}

package/dist/features/commands/useContextualActions.js

@@ -0,0 +1,78 @@
+import { useCallback } from "react";
+import { copyToClipboard } from "../../shared/clipboard.js";
+import { commandLine } from "../../shared/ui/format.js";
+import { t } from "../../shared/i18n/index.js";
+import { groupRunsByCycle } from "../../widgets/right-panel/RunHistory.js";
+export function useContextualActions(context) {
+    const { activeTab, focusedPanel, selected, selectedRunIndex, selectedTask, selectedProjectEntity, tasks, push, setCloneMode, setEditTarget, setPendingTaskSelection, handleCommand, handleOpenRunLog, pushToast, isBoardView, view, logModalRun, commandsBrowserOpen, confirmState, searchState, setChordState, chordState, } = context;
+    const handleContextualCopy = useCallback(() => {
+        const copyHandlers = {
+            loops: () => {
+                if (!selected)
+                    return;
+                const text = selected.commandRaw
+                    ? selected.commandRaw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ")
+                    : commandLine(selected.command, selected.commandArgs);
+                copyToClipboard(text);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+            tasks: () => {
+                if (!selectedTask)
+                    return;
+                const text = selectedTask.commandRaw
+                    ? selectedTask.commandRaw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ")
+                    : commandLine(selectedTask.command, selectedTask.commandArgs);
+                copyToClipboard(text);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+            projects: () => {
+                if (!selectedProjectEntity)
+                    return;
+                copyToClipboard(selectedProjectEntity.name);
+                pushToast("info", t("board.toastTextCopied"));
+            },
+        };
+        const handler = copyHandlers[activeTab];
+        if (handler)
+            handler();
+    }, [activeTab, selected, selectedTask, selectedProjectEntity, pushToast]);
+    const triggerContextualAction = useCallback(() => {
+        if (!isBoardView(view) || logModalRun || commandsBrowserOpen || confirmState || searchState?.active)
+            return;
+        if (chordState)
+            setChordState(null);
+        const editSelectedLoop = () => {
+            if (!selected)
+                return;
+            setCloneMode(false);
+            setEditTarget(selected);
+            const task = selected.taskId ? tasks.find((t) => t.id === selected.taskId) : null;
+            setPendingTaskSelection(task ? { id: task.id, name: task.name } : null);
+            push("create");
+        };
+        const handlers = {
+            "tasks:": () => { if (selectedTask)
+                handleCommand("edit"); },
+            "projects:": () => { if (selectedProjectEntity)
+                handleCommand("edit"); },
+            "loops:right": () => {
+                if (!selected)
+                    return;
+                const reversed = [...groupRunsByCycle(selected.runHistory)].reverse();
+                if (reversed.length > 0) {
+                    const run = reversed[Math.min(selectedRunIndex, reversed.length - 1)];
+                    handleOpenRunLog(run ?? reversed[0]);
+                }
+                else
+                    editSelectedLoop();
+            },
+            "loops:left": editSelectedLoop,
+        };
+        const handlerKey = activeTab !== "loops" ? `${activeTab}:` : `loops:${focusedPanel}`;
+        handlers[handlerKey]?.();
+    }, [activeTab, focusedPanel, view, logModalRun, commandsBrowserOpen, confirmState, searchState,
+        chordState, setChordState, selected, selectedRunIndex, selectedTask, selectedProjectEntity, tasks, push,
+        setCloneMode, setEditTarget, setPendingTaskSelection, handleCommand, handleOpenRunLog,
+        isBoardView]);
+    return { handleContextualCopy, triggerContextualAction };
+}

package/dist/features/commands/useGlobalShortcuts.js

@@ -0,0 +1,154 @@
+import { useInput } from "ink";
+import { MAX_ENTRIES } from "../../shared/ui/DebugPanel.js";
+const FORM_VIEWS = ["create", "task-create", "task-edit", "project-create", "project-edit"];
+function isBoardView(view) {
+    return view === "board";
+}
+export function useGlobalShortcuts(context) {
+    const { activeTab, focusedPanel: _focusedPanel, setFocusedPanel, setActiveTab, view, handleCommand, triggerContextualAction, popLayer, anyModalOpen: _anyModalOpen, debugMode, setDebugEntries, inputOwner: _inputOwner, confirmState, searchState, logModalRun, commandsBrowserOpen, exportModal, diagramModal, contextHelpOpen, setContextHelpOpen, onQuit, exit, setConfirmState, setLogModalRun, setLogModalLoopId, setCommandsBrowserOpen, chordState, setChordState, } = context;
+    useInput((input, key) => {
+        // Swallow SGR mouse sequences — handled by useMouseScroll in each component
+        if (input.includes("[<")) {
+            return;
+        }
+        if (key.ctrl && input === "c") {
+            if (!logModalRun && !confirmState && !commandsBrowserOpen && !exportModal && !diagramModal) {
+                setConfirmState({
+                    prompt: "",
+                    onConfirm: () => { onQuit(); exit(); },
+                });
+                return;
+            }
+        }
+        if (debugMode) {
+            const entry = {
+                id: Date.now(),
+                input,
+                len: input.length,
+                ctrl: key.ctrl,
+                return: key.return,
+                shift: key.shift,
+                meta: key.meta,
+                tab: key.tab,
+                upArrow: key.upArrow,
+                downArrow: key.downArrow,
+                leftArrow: key.leftArrow,
+                rightArrow: key.rightArrow,
+                escape: key.escape,
+                codes: Array.from(input).map((c) => c.charCodeAt(0)).join(","),
+            };
+            setDebugEntries((prev) => [entry, ...prev].slice(0, MAX_ENTRIES));
+        }
+        const isMultiCharEnter = input.length > 1 && (input.includes("\r") || input.includes("\n"));
+        const isCtrlEnter = (key.ctrl && key.return) || input === "\x0e" || isMultiCharEnter;
+        if (isCtrlEnter && isBoardView(view) && !logModalRun && !commandsBrowserOpen && !confirmState && !searchState?.active && !diagramModal) {
+            triggerContextualAction();
+            return;
+        }
+        const canShortcut = key.ctrl && isBoardView(view) && !logModalRun && !commandsBrowserOpen && !confirmState && !searchState?.active && !exportModal && !diagramModal;
+        if (canShortcut) {
+            const globalShortcuts = {
+                p: () => { setCommandsBrowserOpen(true); },
+                b: () => handleCommand("debug"),
+                x: () => handleCommand("export"),
+                i: () => handleCommand("import"),
+            };
+            const filterShortcuts = {
+                s: () => handleCommand("search"),
+                t: () => handleCommand("filter-status"),
+                o: () => handleCommand("sort"),
+                p: () => handleCommand("filter-project"),
+            };
+            const actionShortcuts = {
+                n: () => handleCommand(activeTab === "loops" ? "new-loop" : activeTab === "tasks" ? "new-task" : "new-project"),
+                e: () => handleCommand("edit"),
+                d: () => handleCommand("delete"),
+                ...(activeTab === "loops" ? {
+                    p: () => handleCommand("pause"),
+                    r: () => handleCommand("play"),
+                    s: () => handleCommand("stop"),
+                    t: () => handleCommand("trigger"),
+                    c: () => handleCommand("clone"),
+                    o: () => handleCommand("logs"),
+                } : {}),
+            };
+            if (chordState === "ctrl+f" && filterShortcuts[input]) {
+                filterShortcuts[input]();
+                setChordState(null);
+                return;
+            }
+            if (chordState === "ctrl+a" && actionShortcuts[input]) {
+                actionShortcuts[input]();
+                setChordState(null);
+                return;
+            }
+            if (chordState) {
+                setChordState(null);
+            }
+            if (input === "f") {
+                setChordState("ctrl+f");
+                return;
+            }
+            if (input === "a") {
+                setChordState("ctrl+a");
+                return;
+            }
+            const globalHandler = globalShortcuts[input];
+            if (globalHandler) {
+                globalHandler();
+                return;
+            }
+        }
+        if (confirmState && !key.escape)
+            return;
+        if (searchState?.active && !key.escape)
+            return;
+        if (key.escape) {
+            popLayer();
+            return;
+        }
+        if (logModalRun) {
+            if (input === "q") {
+                setLogModalRun(null);
+                setLogModalLoopId(null);
+            }
+            return;
+        }
+        if (commandsBrowserOpen)
+            return;
+        if (contextHelpOpen) {
+            setContextHelpOpen(false);
+            return;
+        }
+        if (logModalRun)
+            return;
+        if (FORM_VIEWS.includes(view))
+            return;
+        if (isBoardView(view)) {
+            if (key.ctrl && key.rightArrow) {
+                setActiveTab((prev) => prev === "loops" ? "tasks" : prev === "tasks" ? "projects" : "loops");
+                return;
+            }
+            if (key.ctrl && key.leftArrow) {
+                setActiveTab((prev) => prev === "loops" ? "projects" : prev === "tasks" ? "loops" : "tasks");
+                return;
+            }
+            if (key.tab) {
+                setFocusedPanel((prev) => prev === "left" ? "right" : "left");
+                return;
+            }
+            if (input === "1") {
+                setActiveTab("loops");
+                return;
+            }
+            if (input === "2") {
+                setActiveTab("tasks");
+                return;
+            }
+            if (input === "3") {
+                setActiveTab("projects");
+                return;
+            }
+        }
+    });
+}

package/dist/features/forms/FormRouter.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CreateView } from "../../widgets/loop-form/CreateForm.js";
+import { TaskForm } from "../../widgets/task-form/TaskForm.js";
+import { ProjectFormView } from "../../widgets/project-form/ProjectForm.js";
+const TASK_FORM_VIEWS = new Set(["task-create", "task-edit"]);
+function createInitialValues(editTarget, currentProjectId) {
+    if (!editTarget) {
+        return {
+            interval: "30m",
+            taskMode: "inline",
+            command: "",
+            cwd: process.cwd(),
+            taskId: "",
+            description: "",
+            runNow: "y",
+            maxRuns: "",
+            project: currentProjectId,
+            context: "",
+        };
+    }
+    return {
+        interval: editTarget.intervalHuman ?? "30m",
+        taskMode: editTarget.taskId ? "existing" : "inline",
+        command: editTarget.commandRaw ?? [editTarget.command, ...editTarget.commandArgs].join(" "),
+        cwd: editTarget.cwd ?? "",
+        taskId: editTarget.taskId ?? "",
+        description: editTarget.description,
+        runNow: "y",
+        maxRuns: editTarget.maxRuns?.toString() ?? "",
+        project: editTarget.projectId ?? "default",
+        context: editTarget.context ? JSON.stringify(editTarget.context) : "",
+    };
+}
+export function FormRouter(props) {
+    const { view, editTarget, cloneMode, editTask, editProject, pendingTaskSelection, tasks, projects, currentProjectId, cancelCreate, onCreateDone, handleChooseTask, cancelTask, onTaskDone, cancelProject, onProjectDone } = props;
+    if (view === "create") {
+        return (_jsx(CreateView, { mode: editTarget && !cloneMode ? "edit" : "create", editId: editTarget && !cloneMode ? editTarget.id : null, initial: createInitialValues(editTarget, currentProjectId), selectedTaskId: pendingTaskSelection?.id ?? null, selectedTaskName: pendingTaskSelection?.name ?? null, tasks: tasks, projects: projects, currentProjectId: currentProjectId, onCancel: cancelCreate, onDone: onCreateDone, onChooseTask: handleChooseTask }));
+    }
+    if (TASK_FORM_VIEWS.has(view)) {
+        return (_jsx(TaskForm, { mode: view === "task-edit" ? "edit" : "create", editTask: editTask, onCancel: cancelTask, onDone: onTaskDone }));
+    }
+    if (view === "project-create" || view === "project-edit") {
+        return (_jsx(ProjectFormView, { mode: view === "project-edit" ? "edit" : "create", editProject: view === "project-edit" ? editProject : null, onCancel: cancelProject, onDone: onProjectDone }));
+    }
+    return null;
+}

package/dist/features/overlays/ContextHelpModal.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { Modal } from "../../shared/ui/Modal.js";
+import { t } from "../../shared/i18n/index.js";
+export function ContextHelpModal(props) {
+    return (_jsxs(Modal, { title: t("context.helpTitle"), onClose: props.onClose, width: 64, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.text.primary, children: t("context.helpRules") }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.accent.brand, children: t("context.helpTemplates") }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.semantic.warning, children: t("context.helpCaveat") }) }), _jsx(Box, { children: _jsx(Text, { color: theme.text.secondary, children: t("context.helpJqTip") }) })] }));
+}

package/dist/features/overlays/DiagramModal.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { copyToClipboard } from "../../shared/clipboard.js";
+import { useMouseScroll } from "../../shared/hooks/useMouseScroll.js";
+const VISIBLE_LINES = 20;
+export function DiagramModal(props) {
+    const lines = props.diagramText.split("\n");
+    const totalLines = lines.length;
+    const maxScroll = Math.max(0, totalLines - VISIBLE_LINES);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    useInput((input, key) => {
+        if (input.includes("\x1b[200~")) {
+            return;
+        }
+        if (input.includes("[<")) {
+            return;
+        }
+        if (key.escape) {
+            props.onClose();
+            return;
+        }
+        if (key.downArrow) {
+            setScrollOffset((o) => Math.min(o + 1, maxScroll));
+            return;
+        }
+        if (key.upArrow) {
+            setScrollOffset((o) => Math.max(0, o - 1));
+            return;
+        }
+        if (input === "c" && !key.ctrl) {
+            copyToClipboard(props.diagramText);
+            props.onCopy?.();
+            return;
+        }
+    });
+    useMouseScroll({
+        onScrollUp: () => setScrollOffset((o) => Math.max(0, o - 1)),
+        onScrollDown: () => setScrollOffset((o) => Math.min(o + 1, maxScroll)),
+    });
+    const visible = lines.slice(scrollOffset, scrollOffset + VISIBLE_LINES);
+    return (_jsxs(Box, { position: "absolute", top: 0, left: 0, width: "100%", height: "100%", flexDirection: "column", backgroundColor: theme.bg.elevated, borderStyle: "round", borderColor: theme.accent.brand, paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: theme.accent.brand, bold: true, children: t("diagram.modalTitle") }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visible.map((line, i) => (_jsx(Text, { color: theme.text.primary, wrap: "truncate", children: line }, scrollOffset + i))) }), _jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [_jsx(Text, { color: theme.text.muted, children: t("diagram.hint") }), _jsxs(Text, { color: theme.text.muted, children: ["[", scrollOffset, "-", scrollOffset + visible.length, "/", totalLines, "]"] })] })] }));
+}