@plainconceptsplatform/loop-task 2.6.0

package/dist/entities/projects/filters.js

@@ -0,0 +1,69 @@
+export const defaultProjectFilters = {
+    query: "",
+    hasLoops: "all",
+    isSystem: "all",
+    sort: "name",
+};
+export function applyProjectFilters(projects, loops, filters) {
+    const filtered = projects.filter((project) => {
+        if (filters.hasLoops === "with-loops") {
+            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
+            if (count === 0)
+                return false;
+        }
+        if (filters.hasLoops === "empty") {
+            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
+            if (count > 0)
+                return false;
+        }
+        if (filters.isSystem === "system" && !project.isSystem)
+            return false;
+        if (filters.isSystem === "user" && project.isSystem)
+            return false;
+        const query = filters.query.trim().toLowerCase();
+        if (query && !project.name.toLowerCase().includes(query))
+            return false;
+        return true;
+    });
+    return filtered.sort((a, b) => {
+        if (filters.sort === "name") {
+            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+        }
+        if (filters.sort === "loop-count") {
+            const ca = loops.filter((l) => (l.projectId ?? "default") === a.id).length;
+            const cb = loops.filter((l) => (l.projectId ?? "default") === b.id).length;
+            if (cb !== ca)
+                return cb - ca;
+            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+        }
+        const da = a.createdAt;
+        const db = b.createdAt;
+        if (da !== db)
+            return db.localeCompare(da);
+        return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+    });
+}
+const PROJECT_SORT_CYCLE = {
+    name: "loop-count",
+    "loop-count": "created-date",
+    "created-date": "name",
+};
+export function cycleProjectSortMode(mode) {
+    return PROJECT_SORT_CYCLE[mode];
+}
+const PROJECT_HAS_LOOPS_CYCLE = {
+    all: "with-loops",
+    "with-loops": "empty",
+    empty: "all",
+};
+export function cycleProjectHasLoopsFilter(filter) {
+    return PROJECT_HAS_LOOPS_CYCLE[filter];
+}
+const PROJECT_IS_SYSTEM_CYCLE = {
+    all: "system",
+    system: "user",
+    user: "all",
+};
+export function cycleProjectIsSystemFilter(filter) {
+    return PROJECT_IS_SYSTEM_CYCLE[filter];
+}

package/dist/entities/projects/index.js

@@ -0,0 +1 @@
+export { defaultProjectFilters, applyProjectFilters, cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter, } from "./filters.js";

package/dist/entities/tasks/filters.js

@@ -0,0 +1,41 @@
+export const defaultTaskFilters = {
+    query: "",
+    sort: "name",
+};
+function taskSearchableText(task) {
+    return `${task.id} ${task.name} ${task.command} ${task.commandArgs.join(" ")}`.toLowerCase();
+}
+function matches(task, filters) {
+    const query = filters.query.trim().toLowerCase();
+    if (!query)
+        return true;
+    return taskSearchableText(task).includes(query);
+}
+function compare(left, right, sort) {
+    if (sort === "name") {
+        return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+    }
+    if (sort === "command") {
+        const leftCmd = left.commandRaw ?? [left.command, ...left.commandArgs].join(" ");
+        const rightCmd = right.commandRaw ?? [right.command, ...right.commandArgs].join(" ");
+        const byCmd = leftCmd.localeCompare(rightCmd, undefined, { sensitivity: "base" });
+        if (byCmd !== 0)
+            return byCmd;
+        return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+    }
+    // "created"  newest first
+    return right.createdAt.localeCompare(left.createdAt);
+}
+export function applyTaskFilters(tasks, filters) {
+    return tasks
+        .filter((task) => matches(task, filters))
+        .sort((left, right) => compare(left, right, filters.sort));
+}
+const TASK_SORT_CYCLE = {
+    name: "command",
+    command: "created",
+    created: "name",
+};
+export function cycleTaskSortMode(mode) {
+    return TASK_SORT_CYCLE[mode];
+}

package/dist/entities/tasks/index.js

@@ -0,0 +1 @@
+export { defaultTaskFilters, applyTaskFilters, cycleTaskSortMode, } from "./filters.js";

package/dist/entry.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+if (process.env.NODE_ENV === undefined) {
+  process.env.NODE_ENV = "production";
+  process.env.LOOP_TASK_DEFAULTED_NODE_ENV = "1";
+}
+
+import { register } from "node:module";
+import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+register(pathToFileURL(join(__dirname, "esm-loader.js")).href);
+
+import("./cli.js");

package/dist/esm-loader.js

@@ -0,0 +1,39 @@
+import { resolve as pathResolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+
+const EXTENSIONLESS_PATTERNS = [
+  /node_modules\/react-reconciler\/constants$/,
+  /node_modules\/react-reconciler\/reflection$/,
+];
+
+export function resolve(specifier, context, nextResolve) {
+  for (const pattern of EXTENSIONLESS_PATTERNS) {
+    if (pattern.test(specifier)) {
+      return nextResolve(specifier + ".js", context);
+    }
+  }
+
+  if (
+    (specifier.includes("react-reconciler/constants") || specifier.includes("react-reconciler/reflection")) &&
+    !specifier.endsWith(".js")
+  ) {
+    return nextResolve(specifier + ".js", context);
+  }
+
+  if (
+    context.parentURL &&
+    specifier.startsWith(".") &&
+    !specifier.endsWith(".js") &&
+    !specifier.endsWith(".json") &&
+    !specifier.endsWith(".node")
+  ) {
+    const parentDir = dirname(fileURLToPath(context.parentURL));
+    const candidate = pathResolve(parentDir, specifier + ".js");
+    if (fs.existsSync(candidate)) {
+      return nextResolve(specifier + ".js", context);
+    }
+  }
+
+  return nextResolve(specifier, context);
+}

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

@@ -0,0 +1,116 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useMemo, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { useInject } from "../../shared/hooks/useInject.js";
+import { TYPES } from "../../shared/services/types.js";
+import { commandLine } from "../../shared/ui/format.js";
+function buildChains(tasks) {
+    const taskMap = new Map();
+    for (const task of tasks) {
+        taskMap.set(task.id, task);
+    }
+    const referenced = new Set();
+    for (const task of tasks) {
+        if (task.onSuccessTaskId)
+            referenced.add(task.onSuccessTaskId);
+        if (task.onFailureTaskId)
+            referenced.add(task.onFailureTaskId);
+    }
+    const roots = tasks.filter((task) => !referenced.has(task.id));
+    const visited = new Set();
+    function buildNode(task, branch, depth, isLast) {
+        if (visited.has(task.id)) {
+            return { task, children: [], branch, depth, isLast };
+        }
+        visited.add(task.id);
+        const children = [];
+        if (task.onSuccessTaskId) {
+            const child = taskMap.get(task.onSuccessTaskId);
+            if (child)
+                children.push(buildNode(child, "success", depth + 1, false));
+        }
+        if (task.onFailureTaskId) {
+            const child = taskMap.get(task.onFailureTaskId);
+            if (child) {
+                if (children.length > 0)
+                    children[0].isLast = true;
+                children.push(buildNode(child, "failure", depth + 1, true));
+            }
+        }
+        if (children.length > 0)
+            children[children.length - 1].isLast = true;
+        if (children.length === 0 && branch !== null)
+            isLast = true;
+        return { task, children, branch, depth, isLast };
+    }
+    return roots.map((root) => ({
+        root: buildNode(root, null, 0, true),
+    }));
+}
+function flattenTree(node, result = [], prefix = "") {
+    result.push({ node, prefix });
+    for (const child of node.children) {
+        const childPrefix = prefix + (node.isLast ? "  " : "\u2502 ");
+        flattenTree(child, result, childPrefix);
+    }
+    return result;
+}
+export function ChainEditor(props) {
+    const [tasks, setTasks] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const taskService = useInject(TYPES.TaskService);
+    useEffect(() => {
+        taskService.list().then(setTasks).catch(() => setTasks([]));
+    }, [taskService]);
+    const trees = useMemo(() => buildChains(tasks), [tasks]);
+    const flatNodes = useMemo(() => {
+        const all = [];
+        for (const tree of trees) {
+            flattenTree(tree.root, all);
+        }
+        return all;
+    }, [trees]);
+    useInput((_input, key) => {
+        if (_input.includes("[<"))
+            return;
+        if (key.escape) {
+            props.onClose();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((i) => i <= 0 ? flatNodes.length - 1 : i - 1);
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex((i) => i >= flatNodes.length - 1 ? 0 : i + 1);
+            return;
+        }
+        if (key.return) {
+            const node = flatNodes[selectedIndex];
+            if (node && props.onEditTask) {
+                props.onEditTask(node.node.task);
+            }
+            return;
+        }
+    });
+    if (flatNodes.length === 0) {
+        return (_jsxs(Box, { borderStyle: "single", borderColor: theme.accent.task, flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Text, { color: theme.accent.task, bold: true, children: "Chain Editor" }), _jsx(Text, { color: theme.text.muted, children: "No tasks found. Create tasks first to build chains." }), _jsx(Text, { color: theme.text.muted, children: "Press Esc to go back." })] }));
+    }
+    return (_jsxs(Box, { borderStyle: "single", borderColor: theme.accent.task, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: theme.accent.task, bold: true, children: "Chain Editor" }), _jsx(Text, { color: theme.text.muted, children: " - up/down: navigate, enter: edit task, esc: back" })] }), flatNodes.map((item, i) => {
+                const isSelected = i === selectedIndex;
+                const bg = isSelected ? theme.bg.active : undefined;
+                const fg = isSelected ? theme.text.inverse : theme.text.primary;
+                const branchLabel = item.node.branch
+                    ? item.node.branch === "success"
+                        ? "[\u2713] "
+                        : "[\u2717] "
+                    : "";
+                const branchColor = item.node.branch === "success"
+                    ? theme.semantic.success
+                    : item.node.branch === "failure"
+                        ? theme.semantic.danger
+                        : theme.text.primary;
+                return (_jsxs(Box, { backgroundColor: bg, children: [_jsx(Text, { color: theme.text.muted, children: item.prefix }), _jsx(Text, { color: isSelected ? theme.text.inverse : branchColor, children: branchLabel }), _jsx(Text, { color: fg, children: item.node.task.name }), _jsxs(Text, { color: isSelected ? theme.text.inverse : theme.text.muted, children: [" - ", commandLine(item.node.task.command, item.node.task.commandArgs).slice(0, 40)] })] }, `${item.node.task.id}-${i}`));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.text.muted, children: [trees.length, " root(s) | ", tasks.length, " total tasks | ", flatNodes.length, " nodes"] }) })] }));
+}

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

@@ -0,0 +1,375 @@
+/**
+ * Mermaid-to-ASCII renderer for loop-task recipe diagrams.
+ *
+ * Supports the exact Mermaid subset produced by the loop-task-diagram skill v3:
+ *   flowchart TD
+ *       prefixStart("Start<br/>Purpose")
+ *       taskId["Name<br/>Purpose"] -->|✓| target
+ *       taskId("Name<br/>Purpose") -.->|✗| target
+ *       terminalId(("Name<br/>Purpose"))
+ *       classDef start fill:#ffffff,stroke:#172033,...
+ *       classDef decision fill:#fff8e8,stroke:#c75b00,...
+ *       classDef action fill:#eef0ff,stroke:#554cff,...
+ *       classDef idle fill:#202c40,stroke:#738198,...
+ *       classDef failure fill:#fff0f0,stroke:#ef2929,...
+ *       classDef success fill:#e8f8ec,stroke:#18883c,...
+ *       class nodeId className
+ *
+ * Rendering rules:
+ *   - Vertical top-down layout (TD = top-down)
+ *   - Solid arrows for success (✓), dashed for failure (✗)
+ *   - Decision nodes []: square box
+ *   - Action nodes (): rounded box
+ *   - Terminal nodes (()): double-bordered box, color by class
+ *   - Width capped at 80 characters
+ */
+/**
+ * Parse a Mermaid flowchart string into nodes and edges.
+ */
+function parseMermaid(mermaid) {
+    const nodes = new Map();
+    const classMap = new Map();
+    let entryId = null;
+    let firstNode = true;
+    const lines = mermaid.split("\n").map((l) => l.trim()).filter(Boolean);
+    // First pass: collect class assignments
+    for (const line of lines) {
+        if (line.startsWith("class ")) {
+            const rest = line.slice(6).trim();
+            const parts = rest.split(/\s+/);
+            if (parts.length === 2) {
+                const role = parts[1];
+                if (["start", "decision", "action", "idle", "failure", "success"].includes(role)) {
+                    for (const id of parts[0].split(",")) {
+                        classMap.set(id.trim(), role);
+                    }
+                }
+            }
+            continue;
+        }
+    }
+    // Second pass: parse nodes and edges
+    for (const line of lines) {
+        // Skip directives
+        if (line.startsWith("flowchart") || line.startsWith("classDef") || line.startsWith("class "))
+            continue;
+        // Edge lines with box source: id["label"] -->|✓| targetId
+        const solidBoxEdge = line.match(/^(\w+)\["([^"]*?)"\]\s*-->\|([^|]+)\|\s*(\w+)$/);
+        const solidRoundEdge = line.match(/^(\w+)\("([^"]*?)"\)\s*-->\|([^|]+)\|\s*(\w+)$/);
+        const solidDoubleEdge = line.match(/^(\w+)\(\("([^"]*?)"\)\)\s*-->\|([^|]+)\|\s*(\w+)$/);
+        const dashedBoxEdge = line.match(/^(\w+)\["([^"]*?)"\]\s*-\.\->\|([^|]+)\|\s*(\w+)$/);
+        const dashedRoundEdge = line.match(/^(\w+)\("([^"]*?)"\)\s*-\.\->\|([^|]+)\|\s*(\w+)$/);
+        const dashedDoubleEdge = line.match(/^(\w+)\(\("([^"]*?)"\)\)\s*-\.\->\|([^|]+)\|\s*(\w+)$/);
+        // Simple edge (just IDs)
+        const solidSimple = line.match(/^(\w+)\s*-->\|?([^|]*)\|?\s*(\w+)$/);
+        const dashedSimple = line.match(/^(\w+)\s*-\.\->\|?([^|]*)\|?\s*(\w+)$/);
+        // Also handle bare --> without labels
+        const bareSolid = line.match(/^(\w+)\("([^"]*?)"\)\s*-->\s*(\w+)$/);
+        const bareSolidBox = line.match(/^(\w+)\["([^"]*?)"\]\s*-->\s*(\w+)$/);
+        // Standalone node declarations
+        const standaloneBox = line.match(/^(\w+)\["([^"]*?)"\]$/);
+        const standaloneRound = line.match(/^(\w+)\("([^"]*?)"\)$/);
+        const standaloneDouble = line.match(/^(\w+)\(\("([^"]*?)"\)\)$/);
+        if (solidBoxEdge) {
+            const [, fromId, labelText, , toId] = solidBoxEdge;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "box", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).successTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (solidRoundEdge) {
+            const [, fromId, labelText, , toId] = solidRoundEdge;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "round", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).successTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (dashedBoxEdge) {
+            const [, fromId, labelText, , toId] = dashedBoxEdge;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "box", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).failureTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (dashedRoundEdge) {
+            const [, fromId, labelText, , toId] = dashedRoundEdge;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "round", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).failureTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (bareSolid) {
+            const [, fromId, labelText, toId] = bareSolid;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "round", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).successTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (bareSolidBox) {
+            const [, fromId, labelText, toId] = bareSolidBox;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, fromId, name, purpose, "box", classMap);
+            if (firstNode && !entryId) {
+                entryId = fromId;
+                firstNode = false;
+            }
+            nodes.get(fromId).successTarget = toId;
+            ensureNodeById(nodes, toId, classMap);
+        }
+        else if (standaloneDouble) {
+            const [, id, labelText] = standaloneDouble;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, id, name, purpose, "doubleRound", classMap);
+        }
+        else if (standaloneRound) {
+            const [, id, labelText] = standaloneRound;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, id, name, purpose, "round", classMap);
+            if (firstNode && !entryId) {
+                entryId = id;
+                firstNode = false;
+            }
+        }
+        else if (standaloneBox) {
+            const [, id, labelText] = standaloneBox;
+            const { name, purpose } = splitLabel(labelText);
+            ensureNode(nodes, id, name, purpose, "box", classMap);
+        }
+    }
+    return { nodes, entryId };
+}
+function splitLabel(raw) {
+    const label = raw.replace(/<br\/>/g, "\n");
+    const idx = label.indexOf("\n");
+    if (idx === -1)
+        return { name: label, purpose: "" };
+    return { name: label.slice(0, idx), purpose: label.slice(idx + 1) };
+}
+function ensureNode(nodes, id, name, purpose, shape, classMap) {
+    if (!nodes.has(id)) {
+        const role = classMap.get(id) || "none";
+        nodes.set(id, {
+            id,
+            label: name,
+            purpose,
+            shape,
+            role,
+            successTarget: null,
+            failureTarget: null,
+        });
+    }
+}
+function ensureNodeById(nodes, targetId, classMap) {
+    if (!nodes.has(targetId)) {
+        ensureNode(nodes, targetId, targetId, "", "box", classMap);
+    }
+}
+/**
+ * Render a Mermaid flowchart as vertical ASCII art.
+ */
+export function renderMermaidAsAscii(mermaid) {
+    const { nodes, entryId } = parseMermaid(mermaid);
+    const lines = [];
+    const visited = new Set();
+    function renderNode(id, indent) {
+        if (visited.has(id)) {
+            lines.push(" ".repeat(indent) + `↻ back to ${id}`);
+            return;
+        }
+        visited.add(id);
+        const node = nodes.get(id);
+        if (!node)
+            return;
+        const prefix = " ".repeat(indent);
+        const maxContentWidth = 76 - indent;
+        // Build content
+        const content = [];
+        content.push(node.label);
+        if (node.purpose)
+            content.push("  " + node.purpose);
+        const truncated = content.map((l) => l.length > maxContentWidth ? l.slice(0, maxContentWidth - 3) + "..." : l);
+        const boxWidth = Math.min(80, Math.max(...truncated.map((l) => l.length)) + 4);
+        if (node.role === "failure") {
+            // Red terminal — bold box
+            lines.push(prefix + "┏" + "━".repeat(boxWidth - 2) + "┓");
+            for (const line of truncated) {
+                const padded = line + " ".repeat(Math.max(0, boxWidth - 4 - line.length));
+                lines.push(prefix + "┃ " + padded + " ┃");
+            }
+            lines.push(prefix + "┗" + "━".repeat(boxWidth - 2) + "┛");
+        }
+        else if (node.role === "success") {
+            // Green terminal — double border
+            lines.push(prefix + "╔" + "═".repeat(boxWidth - 2) + "╗");
+            for (const line of truncated) {
+                const padded = line + " ".repeat(Math.max(0, boxWidth - 4 - line.length));
+                lines.push(prefix + "║ " + padded + " ║");
+            }
+            lines.push(prefix + "╚" + "═".repeat(boxWidth - 2) + "╝");
+        }
+        else if (node.role === "idle") {
+            // Idle terminal — dotted border
+            lines.push(prefix + "┌" + "┄".repeat(boxWidth - 2) + "┐");
+            for (const line of truncated) {
+                const padded = line + " ".repeat(Math.max(0, boxWidth - 4 - line.length));
+                lines.push(prefix + "┊ " + padded + " ┊");
+            }
+            lines.push(prefix + "└" + "┄".repeat(boxWidth - 2) + "┘");
+        }
+        else if (node.shape === "round" || node.role === "start" || node.role === "action") {
+            // Rounded / start / action — round corners
+            lines.push(prefix + "╭" + "─".repeat(boxWidth - 2) + "╮");
+            for (const line of truncated) {
+                const padded = line + " ".repeat(Math.max(0, boxWidth - 4 - line.length));
+                lines.push(prefix + "│ " + padded + " │");
+            }
+            lines.push(prefix + "╰" + "─".repeat(boxWidth - 2) + "╯");
+        }
+        else {
+            // Decision / default box
+            lines.push(prefix + "┌" + "─".repeat(boxWidth - 2) + "┐");
+            for (const line of truncated) {
+                const padded = line + " ".repeat(Math.max(0, boxWidth - 4 - line.length));
+                lines.push(prefix + "│ " + padded + " │");
+            }
+            lines.push(prefix + "└" + "─".repeat(boxWidth - 2) + "┘");
+        }
+        // Draw edges
+        if (node.successTarget && node.failureTarget) {
+            if (node.successTarget === node.failureTarget) {
+                lines.push(prefix + "  │");
+                lines.push(prefix + "  ├── ✓ ──┐");
+                lines.push(prefix + "  └── ✗ ──┘");
+                renderNode(node.successTarget, indent + 2);
+            }
+            else {
+                lines.push(prefix + "  ├──── ✓ ──▶");
+                renderNode(node.successTarget, indent + 4);
+                lines.push(prefix + "  │");
+                lines.push(prefix + "  └──── ✗ ──▶");
+                renderNode(node.failureTarget, indent + 4);
+            }
+        }
+        else if (node.successTarget) {
+            lines.push(prefix + "  │");
+            lines.push(prefix + "  ✓");
+            lines.push(prefix + "  ▼");
+            renderNode(node.successTarget, indent);
+        }
+        else if (node.failureTarget) {
+            lines.push(prefix + "  │");
+            lines.push(prefix + "  ✗");
+            lines.push(prefix + "  ▼");
+            renderNode(node.failureTarget, indent);
+        }
+    }
+    const startId = entryId || nodes.keys().next().value;
+    if (startId) {
+        renderNode(startId, 0);
+    }
+    return lines.join("\n");
+}
+/**
+ * Fallback: generate a vertical ASCII diagram directly from task definitions.
+ * Used when the recipe has no `diagram:` field.
+ */
+export function renderTaskChainAscii(rootTaskId, tasks) {
+    const taskMap = new Map();
+    for (const task of tasks)
+        taskMap.set(task.id, task);
+    const lines = [];
+    const visited = new Set();
+    function renderTaskNode(taskId) {
+        if (visited.has(taskId)) {
+            lines.push(`  ↻ back to ${taskId}`);
+            return;
+        }
+        visited.add(taskId);
+        const task = taskMap.get(taskId);
+        if (!task) {
+            lines.push(`  ⚠ ${taskId} (missing task)`);
+            return;
+        }
+        const nameLC = (task.name || "").toLowerCase();
+        const isTerminal = !task.onSuccessTaskId && !task.onFailureTaskId;
+        const isFail = isTerminal && (nameLC.includes("fail") || nameLC.includes("recovery") || nameLC.includes("reset"));
+        const isIdle = isTerminal && (task.silentChain || nameLC.includes("idle") || nameLC.includes("nothing"));
+        const isSuccess = isTerminal && !isFail && !isIdle;
+        const lines_content = [task.name];
+        lines_content.push("  " + [task.command, ...task.commandArgs].join(" ").slice(0, 60));
+        const boxWidth = Math.min(80, Math.max(...lines_content.map((l) => l.length)) + 4);
+        if (isFail) {
+            lines.push("┏" + "━".repeat(boxWidth - 2) + "┓");
+            for (const line of lines_content) {
+                lines.push("┃ " + line + " ".repeat(Math.max(0, boxWidth - 4 - line.length)) + " ┃");
+            }
+            lines.push("┗" + "━".repeat(boxWidth - 2) + "┛");
+        }
+        else if (isSuccess) {
+            lines.push("╔" + "═".repeat(boxWidth - 2) + "╗");
+            for (const line of lines_content) {
+                lines.push("║ " + line + " ".repeat(Math.max(0, boxWidth - 4 - line.length)) + " ║");
+            }
+            lines.push("╚" + "═".repeat(boxWidth - 2) + "╝");
+        }
+        else if (isIdle) {
+            lines.push("┌" + "┄".repeat(boxWidth - 2) + "┐");
+            for (const line of lines_content) {
+                lines.push("┊ " + line + " ".repeat(Math.max(0, boxWidth - 4 - line.length)) + " ┊");
+            }
+            lines.push("└" + "┄".repeat(boxWidth - 2) + "┘");
+        }
+        else {
+            lines.push("┌" + "─".repeat(boxWidth - 2) + "┐");
+            for (const line of lines_content) {
+                lines.push("│ " + line + " ".repeat(Math.max(0, boxWidth - 4 - line.length)) + " │");
+            }
+            lines.push("└" + "─".repeat(boxWidth - 2) + "┘");
+        }
+        if (task.onSuccessTaskId && task.onFailureTaskId) {
+            if (task.onSuccessTaskId === task.onFailureTaskId) {
+                lines.push("  ├──── ✓ ──┐");
+                lines.push("  └──── ✗ ──┘");
+                renderTaskNode(task.onSuccessTaskId);
+            }
+            else {
+                lines.push("  ├──── ✓ ──▶");
+                renderTaskNode(task.onSuccessTaskId);
+                lines.push("  └──── ✗ ──▶");
+                renderTaskNode(task.onFailureTaskId);
+            }
+        }
+        else if (task.onSuccessTaskId) {
+            lines.push("  │  ✓");
+            lines.push("  ▼");
+            renderTaskNode(task.onSuccessTaskId);
+        }
+        else if (task.onFailureTaskId) {
+            lines.push("  │  ✗");
+            lines.push("  ▼");
+            renderTaskNode(task.onFailureTaskId);
+        }
+    }
+    renderTaskNode(rootTaskId);
+    return lines.join("\n");
+}