@bpmnkit/cli 0.0.9

package/dist/tui.js

@@ -0,0 +1,2544 @@
+import { spawn } from "node:child_process";
+import { renderBpmnAscii } from "@bpmnkit/ascii";
+import { appendAuditEntry, getAuditLog, getSettings, saveSettings } from "@bpmnkit/profiles";
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const CSI = "\x1b[";
+const HIDE = `${CSI}?25l`;
+const SHOW = `${CSI}?25h`;
+const ALT_ON = `${CSI}?1049h`;
+const ALT_OFF = `${CSI}?1049l`;
+const CLEAR = `${CSI}2J${CSI}H`;
+const inv = (s) => `${CSI}7m${s}${CSI}m`;
+const bold = (s) => `${CSI}1m${s}${CSI}m`;
+const dim = (s) => `${CSI}2m${s}${CSI}m`;
+const green = (s) => `${CSI}32m${s}${CSI}m`;
+const red = (s) => `${CSI}31m${s}${CSI}m`;
+const cyan = (s) => `${CSI}36m${s}${CSI}m`;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: needed for ANSI stripping
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function vlen(s) {
+    return s.replace(ANSI_RE, "").length;
+}
+function padEnd(s, n) {
+    const v = vlen(s);
+    return v < n ? s + " ".repeat(n - v) : s;
+}
+function fit(s, n) {
+    return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+// ─── Capturing output writer ──────────────────────────────────────────────────
+function makeCapturingWriter() {
+    let captured = { type: "messages", lines: [] };
+    function extractItems(data) {
+        if (typeof data === "object" && data !== null && "items" in data) {
+            return data.items;
+        }
+        if (Array.isArray(data))
+            return data;
+        return [data];
+    }
+    function extractTotal(data, items) {
+        if (typeof data === "object" && data !== null) {
+            const page = data.page;
+            if (typeof page === "object" && page !== null) {
+                const t = page.totalItems;
+                if (typeof t === "number")
+                    return t;
+            }
+        }
+        return items.length;
+    }
+    const writer = {
+        format: "table",
+        isInteractive: true,
+        printList(data, columns) {
+            const items = extractItems(data);
+            captured = { type: "list", items, columns, total: extractTotal(data, items) };
+        },
+        printItem(data) {
+            captured = { type: "item", data };
+        },
+        print(data) {
+            if (captured.type === "messages") {
+                const str = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+                for (const line of str.split("\n")) {
+                    captured.lines.push(line);
+                }
+            }
+        },
+        ok(msg) {
+            if (captured.type === "messages")
+                captured.lines.push(`${green("✓")} ${msg}`);
+        },
+        info(msg) {
+            if (captured.type === "messages")
+                captured.lines.push(msg);
+        },
+    };
+    return { writer, get: () => captured };
+}
+// ─── Field helpers ────────────────────────────────────────────────────────────
+const SKIP_FLAGS = new Set(["output", "profile", "help", "no-color", "debug"]);
+function buildFields(cmd) {
+    const fields = [];
+    for (const arg of cmd.args ?? []) {
+        fields.push({
+            kind: "arg",
+            label: arg.name,
+            hint: arg.required ? "required" : "optional",
+            value: "",
+            cursor: 0,
+            required: arg.required ?? false,
+            argSpec: arg,
+        });
+    }
+    for (const flag of cmd.flags ?? []) {
+        if (SKIP_FLAGS.has(flag.name))
+            continue;
+        const hintParts = [
+            flag.type,
+            flag.placeholder ? `<${flag.placeholder}>` : "",
+            flag.required ? "required" : "optional",
+        ];
+        fields.push({
+            kind: "flag",
+            label: `--${flag.name}`,
+            hint: hintParts.filter(Boolean).join(" "),
+            value: flag.default !== undefined ? String(flag.default) : "",
+            cursor: 0,
+            required: flag.required ?? false,
+            flagSpec: flag,
+        });
+    }
+    fields.push({ kind: "run", label: "[ Run ]", hint: "", value: "", cursor: 0, required: false });
+    return fields;
+}
+function buildContext(cmd, fields, writer, getClient, getAdminClient) {
+    const positional = [];
+    const flags = {};
+    for (const f of fields) {
+        if (f.kind === "arg" && f.value)
+            positional.push(f.value);
+        if (f.kind === "flag" && f.value && f.flagSpec) {
+            const { name, type } = f.flagSpec;
+            if (type === "boolean") {
+                flags[name] = f.value === "true" || f.value === "yes" || f.value === "1";
+            }
+            else if (type === "number") {
+                const n = Number(f.value);
+                if (!Number.isNaN(n))
+                    flags[name] = n;
+            }
+            else {
+                flags[name] = f.value;
+            }
+        }
+    }
+    return { positional, flags, output: writer, getClient, getAdminClient };
+}
+// ─── Field type helpers ────────────────────────────────────────────────────────
+function getEnum(field) {
+    if (field.kind === "flag")
+        return field.flagSpec?.enum;
+    if (field.kind === "arg")
+        return field.argSpec?.enum;
+    return undefined;
+}
+function isJsonField(field) {
+    if (field.kind === "flag")
+        return field.flagSpec?.json === true;
+    if (field.kind === "arg")
+        return field.argSpec?.json === true;
+    return false;
+}
+function getPresets(field) {
+    if (field.kind === "flag")
+        return field.flagSpec?.presets;
+    return undefined;
+}
+function parseJsonToEntries(json) {
+    if (!json.trim())
+        return [];
+    try {
+        const obj = JSON.parse(json);
+        return Object.entries(obj).map(([key, val]) => ({
+            key,
+            keyCursor: key.length,
+            val: typeof val === "string" ? val : JSON.stringify(val),
+            valCursor: 0,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function entriesToJson(entries) {
+    const obj = {};
+    for (const e of entries) {
+        if (!e.key)
+            continue;
+        try {
+            obj[e.key] = JSON.parse(e.val);
+        }
+        catch {
+            obj[e.key] = e.val;
+        }
+    }
+    return Object.keys(obj).length === 0 ? "" : JSON.stringify(obj);
+}
+/**
+ * Build initial entries for the JSON editor.
+ * If fieldSpecs are provided, pre-populate with all known fields (in spec order),
+ * merging in any existing values. Extra keys from existing JSON are appended at the end.
+ */
+function buildInitialEntries(existingJson, fieldSpecs) {
+    const existing = {};
+    if (existingJson.trim()) {
+        try {
+            const obj = JSON.parse(existingJson);
+            for (const [k, v] of Object.entries(obj)) {
+                existing[k] = typeof v === "string" ? v : JSON.stringify(v);
+            }
+        }
+        catch {
+            // ignore malformed JSON
+        }
+    }
+    if (!fieldSpecs || fieldSpecs.length === 0)
+        return parseJsonToEntries(existingJson);
+    const seenKeys = new Set();
+    const entries = [];
+    for (const spec of fieldSpecs) {
+        seenKeys.add(spec.name);
+        const val = existing[spec.name] ?? "";
+        entries.push({ key: spec.name, keyCursor: spec.name.length, val, valCursor: val.length });
+    }
+    // Append extra keys not in the spec
+    for (const [k, v] of Object.entries(existing)) {
+        if (!seenKeys.has(k)) {
+            entries.push({ key: k, keyCursor: k.length, val: v, valCursor: v.length });
+        }
+    }
+    return entries;
+}
+/** Look up a JsonFieldSpec by key name. */
+function getFieldSpec(key, fieldSpecs) {
+    return fieldSpecs?.find((s) => s.name === key);
+}
+// ─── Table helpers ────────────────────────────────────────────────────────────
+function getCellStr(item, col) {
+    let val = item;
+    for (const part of col.key.split(".")) {
+        val = val?.[part];
+    }
+    if (col.transform)
+        return col.transform(val);
+    if (val === null || val === undefined)
+        return "—";
+    if (typeof val === "object")
+        return JSON.stringify(val);
+    return String(val);
+}
+function calcColWidths(items, columns, available) {
+    const natural = columns.map((col) => {
+        let max = col.header.length;
+        for (const item of items) {
+            const len = Math.min(getCellStr(item, col).length, col.maxWidth ?? 999);
+            if (len > max)
+                max = len;
+        }
+        return max;
+    });
+    const gap = (columns.length - 1) * 2;
+    const total = natural.reduce((s, w) => s + w, 0) + gap;
+    if (total <= available)
+        return natural;
+    const scale = (available - gap) / natural.reduce((s, w) => s + w, 0);
+    return natural.map((w) => Math.max(5, Math.round(w * scale)));
+}
+/** Sentinel for arrays of objects — displayed as "[N items]", Space to drill down. */
+class ArrayValue {
+    items;
+    constructor(items) {
+        this.items = items;
+    }
+    toString() {
+        return `[${this.items.length} item${this.items.length !== 1 ? "s" : ""}]`;
+    }
+}
+function flattenObj(obj, prefix = "") {
+    // Top-level array (from drill-down): expand each element with [i] prefix
+    if (Array.isArray(obj)) {
+        const result = {};
+        for (let i = 0; i < obj.length; i++) {
+            const elem = obj[i];
+            if (typeof elem === "object" && elem !== null) {
+                Object.assign(result, flattenObj(elem, `[${i}]`));
+            }
+            else {
+                result[`[${i}]`] = elem;
+            }
+        }
+        return result;
+    }
+    if (typeof obj !== "object" || obj === null)
+        return { value: obj };
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (Array.isArray(v)) {
+            if (v.length === 0) {
+                result[key] = "[]";
+            }
+            else if (v.every((item) => typeof item !== "object" || item === null)) {
+                result[key] = v.join(", ");
+            }
+            else {
+                // Arrays of objects: show as collapsed summary; Space to expand
+                result[key] = new ArrayValue(v);
+            }
+        }
+        else if (typeof v === "object" && v !== null) {
+            Object.assign(result, flattenObj(v, key));
+        }
+        else {
+            result[key] = v;
+        }
+    }
+    return result;
+}
+// ─── Render helpers ───────────────────────────────────────────────────────────
+function termSize() {
+    return { cols: process.stdout.columns ?? 80, rows: process.stdout.rows ?? 24 };
+}
+function renderHeader(crumbs, cols, profile) {
+    const title = crumbs.map((c, i) => (i === 0 ? bold(c) : cyan(c))).join(dim(" › "));
+    const profileStr = profile ? dim(`  profile: ${profile}`) : "";
+    const titleLen = crumbs.join(" › ").length + 2;
+    const profileLen = profile ? `  profile: ${profile}`.length : 0;
+    const pad = Math.max(0, cols - 4 - titleLen - profileLen);
+    const header = profileStr ? `  ${title}${" ".repeat(pad)}${profileStr}` : `  ${title}`;
+    return `\n${header}\n  ${dim("─".repeat(cols - 4))}`;
+}
+function renderText(value, cursorPos, width, isEditing) {
+    if (!isEditing)
+        return value ? fit(value, width) : dim("─");
+    const v = value;
+    const c = cursorPos;
+    const start = c >= width ? c - width + 1 : 0;
+    const segment = v.slice(start, start + width + 1);
+    const rel = c - start;
+    const before = segment.slice(0, rel);
+    const ch = segment[rel];
+    const after = segment.slice(rel + (ch ? 1 : 0), rel + width);
+    return `${before}${ch ? inv(ch) : inv(" ")}${after}`;
+}
+function renderFieldValue(field, width, isEditing) {
+    return renderText(field.value, field.cursor, width, isEditing);
+}
+/** Pop the stack all the way back to the main menu (first screen). */
+function popToMain(state) {
+    if (state.stack.length > 1)
+        state.stack.splice(1);
+}
+// ─── Screen renderers ─────────────────────────────────────────────────────────
+function filterGroups(groups, search) {
+    if (!search)
+        return groups;
+    const q = search.toLowerCase();
+    return groups.filter((g) => g.name.toLowerCase().includes(q) || g.description.toLowerCase().includes(q));
+}
+function filterCommands(cmds, search) {
+    if (!search)
+        return cmds;
+    const q = search.toLowerCase();
+    return cmds.filter((c) => c.name.toLowerCase().includes(q) || c.description.toLowerCase().includes(q));
+}
+function renderMain(state, screen) {
+    const { cols, rows } = termSize();
+    const searching = screen.search.length > 0;
+    const viewH = Math.max(3, rows - (searching ? 9 : 7));
+    const groups = filterGroups(state.groups, screen.search);
+    const nameW = state.groups.reduce((m, g) => Math.max(m, g.name.length), 0);
+    const lines = [renderHeader(["casen"], cols, state.profile), ""];
+    if (searching) {
+        lines.push(`  ${dim("/")} ${screen.search}█\n`);
+    }
+    const visible = groups.slice(screen.scroll, screen.scroll + viewH);
+    for (let vi = 0; vi < visible.length; vi++) {
+        const g = visible[vi];
+        if (!g)
+            continue;
+        const i = screen.scroll + vi;
+        const isCursor = i === screen.cursor;
+        const name = padEnd(isCursor ? cyan(g.name) : g.name, nameW + 2);
+        const desc = dim(fit(g.description, cols - nameW - 8));
+        const line = `  ${name}  ${desc}`;
+        lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+    }
+    if (groups.length > viewH) {
+        const hi = Math.min(screen.scroll + viewH, groups.length);
+        lines.push(`\n  ${dim(`${screen.scroll + 1}–${hi} of ${groups.length}`)}`);
+    }
+    const hint = searching
+        ? `  ${dim("↑↓")} navigate  ${cyan("enter")} open  ${cyan("esc")} clear  ${dim("bksp")} delete  ${cyan("^C")} quit`
+        : `  ${dim("↑↓")} navigate  ${cyan("enter")} open  ${dim("type")} search  ${cyan("^C")} quit`;
+    lines.push(`\n${hint}`);
+    return lines;
+}
+function renderCommands(state, screen) {
+    const { cols, rows } = termSize();
+    const searching = screen.search.length > 0;
+    const viewH = Math.max(3, rows - (searching ? 11 : 9));
+    const cmds = filterCommands(screen.group.commands, screen.search);
+    const nameW = screen.group.commands.reduce((m, c) => Math.max(m, c.name.length), 0);
+    const hasMain = state.stack[0]?.kind === "main";
+    const lines = [
+        renderHeader([screen.group.name], cols, state.profile),
+        `\n  ${dim(screen.group.description)}\n`,
+    ];
+    if (searching) {
+        lines.push(`  ${dim("/")} ${screen.search}█\n`);
+    }
+    for (let i = 0; i < cmds.length; i++) {
+        const cmd = cmds[i];
+        if (!cmd)
+            continue;
+        const isCursor = i === screen.cursor;
+        const name = padEnd(isCursor ? cyan(cmd.name) : cmd.name, nameW + 2);
+        const desc = dim(fit(cmd.description, cols - nameW - 8));
+        const line = `  ${name}  ${desc}`;
+        lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+    }
+    if (searching) {
+        lines.push(`\n  ${dim("↑↓")} navigate  ${cyan("enter")} select  ${cyan("esc")} clear  ${dim("bksp")} delete`);
+    }
+    else {
+        const mHint = hasMain ? `  ${cyan("m")} main menu` : "";
+        lines.push(`\n  ${dim("↑↓")} navigate  ${cyan("enter")} select  ${cyan("esc")} back${mHint}  ${dim("type")} search  ${cyan("^C")} quit`);
+    }
+    return lines;
+}
+function renderInput(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 9);
+    const labelW = screen.fields.reduce((m, f) => (f.kind !== "run" ? Math.max(m, f.label.length) : m), 0);
+    const hintW = 26;
+    const valueW = Math.max(20, cols - labelW - hintW - 10);
+    const lines = [
+        renderHeader([screen.group.name, screen.cmd.name], cols, state.profile),
+        `\n  ${dim(screen.cmd.description)}\n`,
+    ];
+    const visible = screen.fields.slice(screen.scroll, screen.scroll + viewH);
+    for (let vi = 0; vi < visible.length; vi++) {
+        const field = visible[vi];
+        if (!field)
+            continue;
+        const fi = screen.scroll + vi;
+        const isCursor = fi === screen.cursor;
+        if (field.kind === "run") {
+            const btn = isCursor ? inv("  Run  ") : dim("[ Run ]");
+            lines.push(`  ${isCursor ? cyan("▶") : " "} ${btn}`);
+            continue;
+        }
+        const marker = isCursor ? cyan("▶") : " ";
+        const label = padEnd(isCursor ? cyan(field.label) : dim(field.label), labelW + 2);
+        const enumVals = getEnum(field);
+        const isJson = isJsonField(field);
+        const presets = getPresets(field);
+        // In edit mode for enum fields, ↑↓ cycle rather than typing
+        const isEnumEditing = screen.editing && isCursor && enumVals !== undefined;
+        const value = isEnumEditing
+            ? enumVals.includes(field.value)
+                ? cyan(padEnd(field.value, valueW))
+                : padEnd(field.value, valueW)
+            : renderFieldValue(field, valueW, screen.editing && isCursor && !isJson);
+        const req = field.required ? red("*") : " ";
+        // Show contextual hint for the focused field
+        let hintText = field.hint;
+        if (isCursor) {
+            if (enumVals) {
+                const idx = enumVals.indexOf(field.value);
+                const pos = idx >= 0 ? `${idx + 1}/${enumVals.length}` : `?/${enumVals.length}`;
+                hintText = `↑↓ pick  ${pos}`;
+            }
+            else if (isJson) {
+                hintText = "→ json editor";
+            }
+            else if (presets) {
+                hintText = "↑↓ preset";
+            }
+        }
+        const hint = isCursor ? cyan(fit(hintText, hintW)) : dim(fit(hintText, hintW));
+        lines.push(`  ${marker} ${label} ${padEnd(value, valueW)}  ${req} ${hint}`);
+    }
+    lines.push("");
+    if (screen.error) {
+        lines.push(`  ${red("error:")} ${screen.error}`);
+    }
+    else if (screen.running) {
+        lines.push(`  ${dim("running…")}`);
+    }
+    else if (screen.editing) {
+        const curField = screen.fields[screen.cursor];
+        const curEnum = curField ? getEnum(curField) : undefined;
+        const curPresets = curField ? getPresets(curField) : undefined;
+        if (curEnum) {
+            lines.push(`  ${dim("↑↓")} cycle  ${cyan("enter")} confirm  ${cyan("esc")} cancel  ${dim(curEnum.join(" | "))}`);
+        }
+        else if (curPresets) {
+            lines.push(`  ${dim("←→")} cursor  ${cyan("↑↓")} presets  ${cyan("enter")} confirm  ${cyan("esc")} cancel`);
+        }
+        else {
+            lines.push(`  ${dim("←→")} cursor  ${cyan("ctrl+a/e")} home/end  ${cyan("ctrl+k/u")} clear  ${cyan("enter")} confirm  ${cyan("esc")} cancel`);
+        }
+    }
+    else {
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} edit/run  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+    }
+    return lines;
+}
+function renderRawView(screen, cols) {
+    const raw = screen.raw;
+    if (!raw)
+        return [`  ${dim("(no raw response captured)")}`];
+    const lines = [];
+    const statusCol = raw.status >= 200 && raw.status < 300 ? green : red;
+    lines.push(`  ${bold("Status:")}  ${statusCol(`HTTP ${raw.status}`)}`);
+    lines.push("");
+    lines.push(`  ${bold("Headers:")}`);
+    for (const [k, v] of Object.entries(raw.headers)) {
+        const kStr = padEnd(cyan(k), 36);
+        lines.push(`  ${kStr}  ${fit(v, cols - 42)}`);
+    }
+    lines.push("");
+    lines.push(`  ${bold("Body:")}`);
+    let bodyLines;
+    try {
+        const parsed = JSON.parse(raw.body);
+        bodyLines = JSON.stringify(parsed, null, 2).split("\n");
+    }
+    catch {
+        bodyLines = raw.body.split("\n");
+    }
+    for (const l of bodyLines) {
+        lines.push(`  ${fit(l, cols - 4)}`);
+    }
+    return lines;
+}
+// ─── Curl view ────────────────────────────────────────────────────────────────
+const CURL_TOKEN_VAR = "CAMUNDA_TOKEN";
+function buildCurlCmd(raw) {
+    const parts = [`curl -X ${raw.method}`];
+    let token = null;
+    for (const [k, v] of Object.entries(raw.requestHeaders)) {
+        let val = v;
+        if (k.toLowerCase() === "authorization") {
+            const m = /^Bearer (.+)$/.exec(v);
+            if (m) {
+                token = m[1] ?? null;
+                val = `Bearer $${CURL_TOKEN_VAR}`;
+            }
+        }
+        parts.push(`  -H '${k}: ${val}'`);
+    }
+    if (raw.requestBody) {
+        parts.push(`  -d '${raw.requestBody.replace(/'/g, "'\\''")}'`);
+    }
+    parts.push(`  '${raw.url}'`);
+    return { cmd: parts.join(" \\\n"), token };
+}
+function copyToClipboard(text) {
+    const cmds = process.platform === "darwin"
+        ? [["pbcopy"]]
+        : process.platform === "win32"
+            ? [["clip"]]
+            : [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+    const tryNext = (i) => {
+        const entry = cmds[i];
+        if (!entry)
+            return;
+        const [bin, ...args] = entry;
+        if (!bin) {
+            tryNext(i + 1);
+            return;
+        }
+        try {
+            const proc = spawn(bin, args, { stdio: ["pipe", "ignore", "ignore"] });
+            proc.on("error", () => tryNext(i + 1));
+            proc.stdin.write(text);
+            proc.stdin.end();
+            proc.unref();
+        }
+        catch {
+            tryNext(i + 1);
+        }
+    };
+    tryNext(0);
+}
+function renderCurlView(screen, cols) {
+    const raw = screen.raw;
+    if (!raw)
+        return [`  ${dim("(no raw response captured)")}`];
+    const { cmd, token } = buildCurlCmd(raw);
+    const lines = [];
+    lines.push(`  ${bold("curl command:")}`);
+    lines.push("");
+    for (const l of cmd.split("\n")) {
+        lines.push(`  ${fit(l, cols - 4)}`);
+    }
+    if (token) {
+        lines.push("");
+        lines.push(`  ${dim(`Token obfuscated as $${CURL_TOKEN_VAR}. Press ${bold("e")} to copy export statement.`)}`);
+    }
+    lines.push("");
+    lines.push(`  ${dim(`Press ${bold("y")} to copy curl command to clipboard.`)}`);
+    return lines;
+}
+function renderResults(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 10);
+    const out = screen.output;
+    const lines = [];
+    const statusBadge = screen.raw
+        ? (() => {
+            const fn = screen.raw.status >= 200 && screen.raw.status < 300 ? green : red;
+            return `  ${dim(fn(`HTTP ${screen.raw.status}`))}`;
+        })()
+        : "";
+    const rawToggle = `  ${screen.rawView ? cyan("r") : dim("r")} ${dim("raw")}`;
+    const curlToggle = screen.raw ? `  ${screen.curlView ? cyan("u") : dim("u")} ${dim("curl")}` : "";
+    if (screen.curlView) {
+        lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
+        lines.push("");
+        const curlLines = renderCurlView(screen, cols);
+        const visible = curlLines.slice(screen.scroll, screen.scroll + rows - 8);
+        for (const l of visible)
+            lines.push(l);
+        lines.push("");
+        if (curlLines.length > rows - 8) {
+            const hi = Math.min(screen.scroll + rows - 8, curlLines.length);
+            lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${curlLines.length}`)}`);
+        }
+        lines.push(`  ${dim("↑↓")} scroll${rawToggle}${curlToggle}  ${cyan("y")} copy curl  ${cyan("e")} copy export  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+        return lines;
+    }
+    if (screen.rawView) {
+        lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
+        lines.push("");
+        const rawLines = renderRawView(screen, cols);
+        const visible = rawLines.slice(screen.scroll, screen.scroll + rows - 8);
+        for (const l of visible)
+            lines.push(l);
+        lines.push("");
+        if (rawLines.length > rows - 8) {
+            const hi = Math.min(screen.scroll + rows - 8, rawLines.length);
+            lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${rawLines.length}`)}`);
+        }
+        lines.push(`  ${dim("↑↓")} scroll${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+        return lines;
+    }
+    if (out.type === "list") {
+        lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
+        lines.push(`\n  ${dim(`${out.total} item${out.total !== 1 ? "s" : ""}`)}${statusBadge}\n`);
+        const available = cols - 4;
+        const widths = calcColWidths(out.items, out.columns, available);
+        const header = out.columns
+            .map((col, i) => padEnd(dim(col.header), widths[i] ?? col.header.length))
+            .join("  ");
+        lines.push(`  ${header}`);
+        lines.push(`  ${dim("─".repeat(available))}`);
+        const visible = out.items.slice(screen.scroll, screen.scroll + viewH);
+        for (let vi = 0; vi < visible.length; vi++) {
+            const item = visible[vi];
+            if (!item)
+                continue;
+            const isCursor = screen.scroll + vi === screen.cursor;
+            const cells = out.columns.map((col, ci) => {
+                const w = widths[ci] ?? 10;
+                return padEnd(fit(getCellStr(item, col), w), w);
+            });
+            const line = `  ${cells.join("  ")}`;
+            lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+        }
+        lines.push("");
+        if (out.total > viewH) {
+            const hi = Math.min(screen.scroll + viewH, out.total);
+            lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${out.total}`)}`);
+        }
+        const followupHint = screen.cmd.relations ? `  ${cyan("f")} follow-up` : "";
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} detail${followupHint}  ${dim("pgup/pgdn")} page${rawToggle}${curlToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+    }
+    else if (out.type === "item") {
+        lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
+        lines.push(statusBadge ? `\n${statusBadge}` : "");
+        const flat = flattenObj(out.data);
+        const entries = Object.entries(flat);
+        const kw = entries.reduce((m, [k]) => Math.max(m, k.length), 0);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (!entry)
+                continue;
+            const [k, v] = entry;
+            const isCursor = i === screen.cursor;
+            const isArr = v instanceof ArrayValue;
+            const valueStr = v === null || v === undefined ? dim("—") : String(v);
+            const hint = isArr && isCursor ? `  ${dim("[space] expand")}` : "";
+            const line = `  ${padEnd(cyan(k), kw + 2)}  ${valueStr}${hint}`;
+            lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+        }
+        const spaceHint = entries.some(([, v]) => v instanceof ArrayValue)
+            ? `  ${cyan("space")} expand array`
+            : "";
+        lines.push(`\n${rawToggle}${curlToggle}${spaceHint}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+    }
+    else {
+        lines.push(renderHeader([screen.group.name, screen.cmd.name], cols, state.profile));
+        lines.push(statusBadge ? `\n${statusBadge}` : "");
+        const displayLines = screen.altView && out.altLines ? out.altLines : out.lines;
+        const altToggle = out.altLines
+            ? `  ${screen.altView ? cyan("x") : dim("x")} ${dim("ascii")}`
+            : "";
+        if (displayLines.length === 0) {
+            lines.push(`  ${dim("(no output)")}`);
+        }
+        else {
+            const hOff = screen.altView ? 0 : screen.cursor;
+            const visible = displayLines.slice(screen.scroll, screen.scroll + viewH);
+            for (const line of visible) {
+                lines.push(`  ${fit(line.slice(hOff), cols - 4)}`);
+            }
+            if (displayLines.length > viewH || hOff > 0) {
+                const hi = Math.min(screen.scroll + viewH, displayLines.length);
+                const panHint = hOff > 0 ? `  col +${hOff}` : "";
+                lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${displayLines.length}${panHint}`)}`);
+            }
+        }
+        lines.push(`\n  ${dim("↑↓←→")} scroll/pan${rawToggle}${curlToggle}${altToggle}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+    }
+    return lines;
+}
+function renderDetail(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 7);
+    const flat = flattenObj(screen.item);
+    const entries = Object.entries(flat);
+    const kw = entries.reduce((m, [k]) => Math.max(m, k.length), 0);
+    const lines = [renderHeader([screen.group.name, screen.label], cols, state.profile), ""];
+    const visible = entries.slice(screen.scroll, screen.scroll + viewH);
+    for (let vi = 0; vi < visible.length; vi++) {
+        const entry = visible[vi];
+        if (!entry)
+            continue;
+        const [k, v] = entry;
+        const isCursor = screen.scroll + vi === screen.cursor;
+        const isArr = v instanceof ArrayValue;
+        const valueStr = v === null || v === undefined ? dim("—") : String(v);
+        const hint = isArr && isCursor ? `  ${dim("[space] expand")}` : "";
+        const line = `  ${padEnd(cyan(k), kw + 2)}  ${valueStr}${hint}`;
+        lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+    }
+    lines.push("");
+    if (entries.length > viewH) {
+        const hi = Math.min(screen.scroll + viewH, entries.length);
+        lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${entries.length} fields`)}`);
+    }
+    const spaceHint = entries.some(([, v]) => v instanceof ArrayValue)
+        ? `  ${cyan("space/→")} expand  ${cyan("←")} back`
+        : `  ${cyan("←")} back`;
+    lines.push(`  ${dim("↑↓")} navigate${spaceHint}  ${cyan("m")} main menu  ${cyan("esc")} back  ${cyan("q")} quit`);
+    return lines;
+}
+function renderFollowup(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 8);
+    const lines = [
+        renderHeader([screen.sourceGroup.name, "follow-up actions"], cols, state.profile),
+        "",
+    ];
+    // Show the fields that will be pre-filled
+    const usedFields = new Set();
+    for (const rel of screen.relations) {
+        for (const p of rel.params)
+            usedFields.add(p.field);
+    }
+    const summary = [...usedFields]
+        .map((f) => `${dim(f)}: ${String(screen.item[f] ?? "")}`)
+        .join("   ");
+    if (summary) {
+        lines.push(`  ${summary}`);
+        lines.push("");
+    }
+    const visible = screen.relations.slice(screen.scroll, screen.scroll + viewH);
+    for (let vi = 0; vi < visible.length; vi++) {
+        const rel = visible[vi];
+        if (!rel)
+            continue;
+        const isCursor = screen.scroll + vi === screen.cursor;
+        const gName = padEnd(cyan(rel.group.name), 22);
+        const cName = rel.cmd.name.padEnd(26);
+        const line = `  ${gName}  ${cName}  ${dim(fit(rel.cmd.description, cols - 56))}`;
+        lines.push(isCursor ? inv(line.padEnd(cols - 1)) : line);
+    }
+    lines.push("");
+    if (screen.relations.length > viewH) {
+        const hi = Math.min(screen.scroll + viewH, screen.relations.length);
+        lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${screen.relations.length}`)}`);
+    }
+    lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} run pre-filled  ${cyan("esc")} back  ${cyan("q")} quit`);
+    return lines;
+}
+function renderProfile(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 7);
+    const kw = state.profileInfo.reduce((m, { key }) => Math.max(m, key.length), 0);
+    const lines = [renderHeader(["profile"], cols, state.profile), ""];
+    const visible = state.profileInfo.slice(screen.scroll, screen.scroll + viewH);
+    for (const { key, value } of visible) {
+        lines.push(`  ${padEnd(cyan(key), kw + 2)}  ${value}`);
+    }
+    lines.push("");
+    if (state.profileInfo.length > viewH) {
+        const hi = Math.min(screen.scroll + viewH, state.profileInfo.length);
+        lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${state.profileInfo.length}`)}`);
+    }
+    lines.push(`  ${dim("↑↓")} scroll  ${cyan("esc/p")} close  ${cyan("q")} quit`);
+    return lines;
+}
+const SETTINGS_ROWS = [
+    {
+        kind: "number",
+        key: "auditLogSize",
+        label: "Audit Log Size",
+        description: "Number of actions to keep per profile  (0 = disabled)",
+        min: 0,
+        max: 1000,
+    },
+    {
+        kind: "action",
+        id: "show-audit-log",
+        label: "Show Audit Log",
+        description: "View recent commands executed for the active profile",
+    },
+];
+function renderSettings(state, screen) {
+    const { cols } = termSize();
+    const settings = getSettings();
+    const labelW = SETTINGS_ROWS.reduce((m, r) => Math.max(m, r.label.length), 0) + 2;
+    const lines = [renderHeader(["settings"], cols, state.profile), ""];
+    for (let i = 0; i < SETTINGS_ROWS.length; i++) {
+        const row = SETTINGS_ROWS[i];
+        if (!row)
+            continue;
+        const isCursor = i === screen.cursor;
+        let valueStr;
+        if (row.kind === "number") {
+            valueStr =
+                screen.editing && isCursor
+                    ? cyan(`[${screen.editValue}_]`)
+                    : bold(String(settings[row.key]));
+        }
+        else {
+            valueStr = dim("→");
+        }
+        const labelPart = padEnd(isCursor ? cyan(row.label) : row.label, labelW);
+        const content = `  ${labelPart}  ${valueStr}`;
+        lines.push(isCursor ? inv(content.padEnd(cols - 1)) : content);
+    }
+    const row = SETTINGS_ROWS[screen.cursor];
+    if (row) {
+        lines.push("");
+        lines.push(`  ${dim(row.description)}`);
+    }
+    lines.push("");
+    if (screen.message) {
+        lines.push(`  ${screen.message}`);
+    }
+    else if (screen.editing) {
+        lines.push(`  ${dim("type")} new value  ${cyan("enter")} save  ${cyan("esc")} cancel  ${dim("bksp")} delete`);
+    }
+    else {
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("enter")} select  ${cyan("esc")} back  ${cyan("q")} quit`);
+    }
+    return lines;
+}
+// ─── Audit log screen ─────────────────────────────────────────────────────────
+function renderAuditLog(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 8);
+    const entries = getAuditLog(state.profile || undefined);
+    const lines = [renderHeader(["settings", "audit log"], cols, state.profile), ""];
+    if (entries.length === 0) {
+        lines.push(`  ${dim(`No audit log entries for profile "${state.profile || "default"}".`)}`);
+    }
+    else {
+        const tsW = 19;
+        const stW = 5;
+        const cmdW = Math.max(20, cols - tsW - stW - 8);
+        lines.push(`  ${dim(padEnd("TIME", tsW + 2))}  ${dim(padEnd("COMMAND", cmdW))}  ${dim("STATUS")}`);
+        lines.push(`  ${dim("─".repeat(cols - 4))}`);
+        const visible = entries.slice(screen.scroll, screen.scroll + viewH);
+        for (const e of visible) {
+            const ts = dim(e.timestamp.replace("T", " ").slice(0, tsW));
+            const cmd = fit(`${e.group} ${e.command}${e.positional.length ? ` ${e.positional.join(" ")}` : ""}`, cmdW);
+            const status = e.status === "ok" ? green("ok") : red("err");
+            lines.push(`  ${ts}  ${padEnd(cmd, cmdW)}  ${status}`);
+        }
+        if (entries.length > viewH) {
+            const hi = Math.min(screen.scroll + viewH, entries.length);
+            lines.push(`\n  ${dim(`${screen.scroll + 1}–${hi} of ${entries.length}`)}`);
+        }
+    }
+    lines.push(`\n  ${dim("↑↓")} scroll  ${cyan("esc")} back  ${cyan("q")} quit`);
+    return lines;
+}
+function renderWorker(state, screen) {
+    const { cols, rows } = termSize();
+    const viewH = Math.max(3, rows - 13);
+    const statusStr = screen.status === "running"
+        ? green("● RUNNING")
+        : screen.status === "starting"
+            ? dim("◌ STARTING")
+            : screen.status === "stopping"
+                ? cyan("◌ STOPPING")
+                : dim("■ STOPPED");
+    const lines = [renderHeader(["job", "worker"], cols, state.profile), ""];
+    lines.push(`  ${padEnd(dim("type"), 8)}  ${cyan(screen.jobType)}    ${dim("status")}  ${statusStr}`);
+    lines.push(`  ${dim("─".repeat(cols - 4))}`);
+    const { activated, completed, failed } = screen.stats;
+    lines.push(`  ${dim("activated")}  ${bold(String(activated))}    ${dim("completed")}  ${completed > 0 ? green(String(completed)) : dim("0")}    ${dim("failed")}  ${failed > 0 ? red(String(failed)) : dim("0")}`);
+    lines.push(`  ${dim("─".repeat(cols - 4))}`);
+    lines.push("");
+    if (screen.log.length === 0) {
+        lines.push(`  ${dim("Waiting for jobs…")}`);
+    }
+    else {
+        const logLines = screen.log.map((e) => {
+            const ts = dim(e.ts);
+            const msg = e.level === "ok"
+                ? `${green("✓")} ${e.text}`
+                : e.level === "err"
+                    ? `${red("✗")} ${e.text}`
+                    : `  ${dim(e.text)}`;
+            return `  ${ts}  ${msg}`;
+        });
+        const visible = logLines.slice(screen.scroll, screen.scroll + viewH);
+        for (const l of visible)
+            lines.push(fit(l, cols - 2));
+        if (screen.log.length > viewH) {
+            const hi = Math.min(screen.scroll + viewH, screen.log.length);
+            lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${screen.log.length}`)}`);
+        }
+    }
+    const isRunning = screen.status === "running" || screen.status === "starting";
+    const autoHint = `  ${screen.autoScroll ? cyan("a") : dim("a")} ${dim("auto")}`;
+    const navHint = isRunning
+        ? `  ${cyan("s")} ${dim("stop")}`
+        : `  ${cyan("esc")} back  ${cyan("m")} main menu`;
+    lines.push(`\n  ${dim("↑↓")} scroll${autoHint}${navHint}  ${cyan("q")} quit`);
+    return lines;
+}
+function renderJsonEditor(state, screen) {
+    const { cols, rows } = termSize();
+    // Reserve extra row for field hint line
+    const viewH = Math.max(3, rows - 10);
+    const keyW = Math.max(14, Math.min(28, Math.floor((cols - 12) * 0.38)));
+    const valW = Math.max(16, cols - keyW - 12);
+    const lines = [
+        renderHeader([screen.group.name, screen.cmd.name, `--${screen.fieldLabel}`], cols, state.profile),
+        "",
+    ];
+    lines.push(`  ${padEnd(dim("KEY"), keyW + 4)}${dim("VALUE")}`);
+    lines.push(`  ${dim("─".repeat(cols - 4))}`);
+    // entries + add-row
+    const rowCount = screen.entries.length + 1;
+    const visible = Math.min(viewH, rowCount);
+    for (let vi = 0; vi < visible; vi++) {
+        const absIdx = screen.scroll + vi;
+        const isCursor = absIdx === screen.cursor;
+        const marker = isCursor ? cyan("▶") : " ";
+        if (absIdx === screen.entries.length) {
+            // "add" row
+            const label = `${isCursor ? cyan("+ add field") : dim("+ add field")}`;
+            lines.push(isCursor ? inv(`  ${marker} ${label}`.padEnd(cols - 1)) : `  ${marker} ${label}`);
+            continue;
+        }
+        const entry = screen.entries[absIdx];
+        if (!entry)
+            continue;
+        const spec = getFieldSpec(entry.key, screen.fieldSpecs);
+        const isKnown = spec !== undefined;
+        const hasEnum = spec?.enum && spec.enum.length > 0;
+        const editKey = isCursor && screen.col === "key" && screen.editing;
+        const editVal = isCursor && screen.col === "val" && screen.editing;
+        const keyStr = renderText(entry.key, entry.keyCursor, keyW - (isKnown ? 0 : 0), editKey);
+        // For known enum fields in nav mode, show cycling hint instead of raw value
+        const valDisplay = !editVal && hasEnum && entry.val
+            ? `${entry.val} ${dim("↑↓")}`
+            : !editVal && hasEnum && !entry.val
+                ? dim("<pick ↑↓>")
+                : renderText(entry.val, entry.valCursor, valW - 4, editVal);
+        const valStr = valDisplay;
+        const keyPart = isCursor && screen.col === "key" && !editKey
+            ? cyan(padEnd(keyStr, keyW))
+            : isKnown
+                ? padEnd(keyStr, keyW)
+                : dim(padEnd(keyStr, keyW));
+        const valPart = isCursor && screen.col === "val" && !editVal
+            ? cyan(padEnd(valStr, valW))
+            : padEnd(valStr, valW);
+        const line = `  ${marker} ${keyPart}  ${valPart}`;
+        lines.push(isCursor && !screen.editing ? inv(line.padEnd(cols - 1)) : line);
+    }
+    lines.push("");
+    // Field hint line: show description/type for the row under the cursor
+    const cursorEntry = screen.entries[screen.cursor];
+    const cursorSpec = cursorEntry ? getFieldSpec(cursorEntry.key, screen.fieldSpecs) : undefined;
+    if (cursorSpec) {
+        const req = cursorSpec.required ? red("required") : dim("optional");
+        const typeStr = cursorSpec.enum
+            ? `enum(${cursorSpec.enum.slice(0, 3).join("|")}${cursorSpec.enum.length > 3 ? "…" : ""})`
+            : cursorSpec.type;
+        const desc = cursorSpec.description ? ` — ${fit(cursorSpec.description, 40)}` : "";
+        lines.push(`  ${dim(typeStr)} ${req}${desc}`);
+    }
+    else {
+        lines.push("");
+    }
+    if (rowCount > viewH) {
+        const hi = Math.min(screen.scroll + viewH, rowCount);
+        lines.push(`  ${dim(`${screen.scroll + 1}–${hi} of ${rowCount}`)}`);
+    }
+    if (screen.error) {
+        lines.push(`  ${red("error:")} ${screen.error}`);
+    }
+    else if (screen.editing) {
+        const cursorEntryEditing = screen.entries[screen.cursor];
+        const editSpec = screen.col === "val" && cursorEntryEditing
+            ? getFieldSpec(cursorEntryEditing.key, screen.fieldSpecs)
+            : undefined;
+        const editHint = editSpec?.enum
+            ? `${dim("↑↓")} pick value  ${cyan("enter")} confirm  ${cyan("esc")} cancel`
+            : `${dim("←→")} cursor  ${cyan("tab")} switch col  ${cyan("enter")} confirm  ${cyan("esc")} cancel`;
+        lines.push(`  ${editHint}`);
+    }
+    else {
+        lines.push(`  ${dim("↑↓")} navigate  ${cyan("tab")} switch col  ${cyan("enter")} edit  ${cyan("a")} add  ${cyan("d")} del  ${cyan("esc")} save  ${cyan("q")} quit`);
+    }
+    return lines;
+}
+// ─── Worker view helpers ──────────────────────────────────────────────────────
+function workerLogH() {
+    return Math.max(3, (process.stdout.rows ?? 24) - 13);
+}
+function addWorkerLog(ws, level, text) {
+    const now = new Date();
+    const ts = [now.getHours(), now.getMinutes(), now.getSeconds()]
+        .map((n) => String(n).padStart(2, "0"))
+        .join(":");
+    ws.log.push({ ts, level, text });
+    if (ws.log.length > 500)
+        ws.log.shift();
+    if (ws.autoScroll)
+        ws.scroll = Math.max(0, ws.log.length - workerLogH());
+}
+function stopWorkerScreen(ws) {
+    if (ws._timer !== null) {
+        clearInterval(ws._timer);
+        ws._timer = null;
+    }
+    if (ws._stop) {
+        ws._stop();
+        ws._stop = null;
+    }
+}
+async function runWorkerLoop(ws, state, variables, jobTimeout, maxJobs) {
+    let client;
+    try {
+        client = await state.getClient();
+    }
+    catch (err) {
+        addWorkerLog(ws, "err", `Client error: ${err instanceof Error ? err.message : String(err)}`);
+        ws.status = "stopped";
+        stopWorkerScreen(ws);
+        return;
+    }
+    let running = true;
+    ws._stop = () => {
+        running = false;
+        ws.status = "stopping";
+        ws._stop = null;
+    };
+    ws.status = "running";
+    addWorkerLog(ws, "info", `Worker started for type "${ws.jobType}"`);
+    addWorkerLog(ws, "info", `Returning: ${JSON.stringify(variables)}`);
+    while (running) {
+        let result;
+        try {
+            result = (await client.job.activateJobs({
+                type: ws.jobType,
+                worker: "casen-worker",
+                timeout: jobTimeout,
+                maxJobsToActivate: maxJobs,
+                requestTimeout: 20000,
+            }));
+        }
+        catch (err) {
+            if (!running)
+                break;
+            addWorkerLog(ws, "err", `Poll error: ${err instanceof Error ? err.message : String(err)} — retry in 5s`);
+            await new Promise((r) => setTimeout(r, 5000));
+            continue;
+        }
+        const jobs = result?.jobs ?? [];
+        for (const job of jobs) {
+            if (!running)
+                break;
+            ws.stats.activated++;
+            addWorkerLog(ws, "info", `Activated ${job.jobKey}  process=${job.processDefinitionId}  element=${job.elementId}`);
+            try {
+                await client.job.completeJob(job.jobKey, { variables });
+                ws.stats.completed++;
+                addWorkerLog(ws, "ok", `Completed ${job.jobKey}`);
+            }
+            catch (err) {
+                ws.stats.failed++;
+                addWorkerLog(ws, "err", `Failed to complete ${job.jobKey}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (jobs.length > 0)
+            await new Promise((r) => setTimeout(r, 100));
+    }
+    ws.status = "stopped";
+    addWorkerLog(ws, "info", `Stopped. Activated: ${ws.stats.activated}  Completed: ${ws.stats.completed}  Failed: ${ws.stats.failed}`);
+    stopWorkerScreen(ws);
+}
+function launchWorkerView(inputScreen, state) {
+    const typeArg = inputScreen.fields.find((f) => f.kind === "arg");
+    const jobType = typeArg?.value?.trim() ?? "";
+    if (!jobType) {
+        inputScreen.error = '"type" is required';
+        return;
+    }
+    let variables = { result: "sample-value" };
+    const varField = inputScreen.fields.find((f) => f.label === "--variables");
+    if (varField?.value) {
+        try {
+            const parsed = JSON.parse(varField.value);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                variables = parsed;
+            }
+        }
+        catch {
+            // use default
+        }
+    }
+    const timeoutField = inputScreen.fields.find((f) => f.label === "--timeout");
+    const workerTimeout = timeoutField?.value ? Number(timeoutField.value) : 30000;
+    const maxJobsField = inputScreen.fields.find((f) => f.label === "--max-jobs");
+    const maxJobs = maxJobsField?.value ? Number(maxJobsField.value) : 32;
+    const ws = {
+        kind: "worker",
+        group: inputScreen.group,
+        cmd: inputScreen.cmd,
+        jobType,
+        status: "starting",
+        stats: { activated: 0, completed: 0, failed: 0 },
+        log: [],
+        scroll: 0,
+        autoScroll: true,
+        _stop: null,
+        _timer: null,
+    };
+    state.stack.push(ws);
+    render(state);
+    // Re-render at 200 ms so live updates appear without waiting for key presses
+    ws._timer = setInterval(() => {
+        if (!state.quitting && state.stack.includes(ws)) {
+            render(state);
+        }
+        else {
+            if (ws._timer !== null) {
+                clearInterval(ws._timer);
+                ws._timer = null;
+            }
+        }
+    }, 200);
+    // Fire-and-forget: the loop writes to ws state; the timer re-renders
+    runWorkerLoop(ws, state, variables, workerTimeout, maxJobs).catch((err) => {
+        addWorkerLog(ws, "err", `Unexpected: ${err instanceof Error ? err.message : String(err)}`);
+        ws.status = "stopped";
+        stopWorkerScreen(ws);
+    });
+}
+function render(state) {
+    if (state.quitting)
+        return;
+    const screen = state.stack[state.stack.length - 1];
+    if (!screen)
+        return;
+    let lines;
+    switch (screen.kind) {
+        case "main":
+            lines = renderMain(state, screen);
+            break;
+        case "commands":
+            lines = renderCommands(state, screen);
+            break;
+        case "input":
+            lines = renderInput(state, screen);
+            break;
+        case "results":
+            lines = renderResults(state, screen);
+            break;
+        case "detail":
+            lines = renderDetail(state, screen);
+            break;
+        case "followup":
+            lines = renderFollowup(state, screen);
+            break;
+        case "profile":
+            lines = renderProfile(state, screen);
+            break;
+        case "settings":
+            lines = renderSettings(state, screen);
+            break;
+        case "audit-log":
+            lines = renderAuditLog(state, screen);
+            break;
+        case "worker":
+            lines = renderWorker(state, screen);
+            break;
+        case "json-editor":
+            lines = renderJsonEditor(state, screen);
+            break;
+    }
+    process.stdout.write(`${CLEAR}${lines.join("\n")}\n`);
+}
+// ─── Key handlers ─────────────────────────────────────────────────────────────
+function handleMainKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const searching = screen.search.length > 0;
+    const viewH = Math.max(3, rows - (searching ? 9 : 7));
+    const groups = filterGroups(state.groups, screen.search);
+    // Backspace removes last search char
+    if (key === "\x7f" || key === "\x08") {
+        screen.search = screen.search.slice(0, -1);
+        screen.cursor = 0;
+        screen.scroll = 0;
+        render(state);
+        return;
+    }
+    // Ctrl+C quits unconditionally
+    if (key === "\x03") {
+        done();
+        return;
+    }
+    // ESC clears search; quits only when search is already empty
+    if (key === "\x1b") {
+        if (searching) {
+            screen.search = "";
+            screen.cursor = 0;
+            screen.scroll = 0;
+        }
+        else {
+            done();
+            return;
+        }
+        render(state);
+        return;
+    }
+    switch (key) {
+        case "\x1b[A": // up
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B": // down
+            if (screen.cursor < groups.length - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\x1b[5~": // page up
+            screen.cursor = Math.max(0, screen.cursor - viewH);
+            screen.scroll = Math.max(0, screen.scroll - viewH);
+            break;
+        case "\x1b[6~": // page down
+            screen.cursor = Math.min(groups.length - 1, screen.cursor + viewH);
+            screen.scroll = Math.min(Math.max(0, groups.length - viewH), screen.scroll + viewH);
+            break;
+        case "\r":
+        case "\n": {
+            const group = groups[screen.cursor];
+            if (group?.name === "settings") {
+                state.stack.push({
+                    kind: "settings",
+                    cursor: 0,
+                    editing: false,
+                    editValue: "",
+                    message: "",
+                });
+            }
+            else if (group) {
+                state.stack.push({ kind: "commands", group, cursor: 0, search: "" });
+            }
+            break;
+        }
+        default:
+            // Any printable char starts/extends search
+            if (key.length === 1 && key >= " ") {
+                screen.search += key;
+                screen.cursor = 0;
+                screen.scroll = 0;
+            }
+    }
+    render(state);
+}
+function handleCommandsKey(key, screen, state, done) {
+    const searching = screen.search.length > 0;
+    const cmds = filterCommands(screen.group.commands, screen.search);
+    // Backspace removes last search char
+    if (key === "\x7f" || key === "\x08") {
+        screen.search = screen.search.slice(0, -1);
+        screen.cursor = 0;
+        render(state);
+        return;
+    }
+    // Ctrl+C quits unconditionally
+    if (key === "\x03") {
+        done();
+        return;
+    }
+    // ESC clears search; goes back when search already empty
+    if (key === "\x1b") {
+        if (searching) {
+            screen.search = "";
+            screen.cursor = 0;
+        }
+        else {
+            state.stack.pop();
+        }
+        render(state);
+        return;
+    }
+    switch (key) {
+        case "\x1b[A":
+            if (screen.cursor > 0)
+                screen.cursor--;
+            break;
+        case "\x1b[B":
+            if (screen.cursor < cmds.length - 1)
+                screen.cursor++;
+            break;
+        case "\r":
+        case "\n": {
+            const cmd = cmds[screen.cursor];
+            if (cmd) {
+                state.stack.push({
+                    kind: "input",
+                    group: screen.group,
+                    cmd,
+                    fields: buildFields(cmd),
+                    cursor: 0,
+                    scroll: 0,
+                    editing: false,
+                    error: "",
+                    running: false,
+                });
+            }
+            break;
+        }
+        default:
+            if (key === "m" || key === "M") {
+                if (!searching) {
+                    popToMain(state);
+                    break;
+                }
+            }
+            // Any printable char starts/extends search
+            if (key.length === 1 && key >= " ") {
+                screen.search += key;
+                screen.cursor = 0;
+            }
+    }
+    render(state);
+}
+async function executeCommand(screen, state) {
+    for (const f of screen.fields) {
+        if (f.required && !f.value) {
+            screen.error = `"${f.label}" is required`;
+            return;
+        }
+    }
+    screen.running = true;
+    screen.error = "";
+    render(state);
+    const { writer, get } = makeCapturingWriter();
+    // Wrap client factories to capture the last raw HTTP response
+    let rawCapture = null;
+    const getClient = async () => {
+        const client = await state.getClient();
+        client.on("rawResponse", (evt) => {
+            rawCapture = evt;
+        });
+        return client;
+    };
+    const getAdminClient = async () => {
+        const client = await state.getAdminClient();
+        client.on("rawResponse", (evt) => {
+            rawCapture = evt;
+        });
+        return client;
+    };
+    const ctx = buildContext(screen.cmd, screen.fields, writer, getClient, getAdminClient);
+    const SECRET_FLAG_RE = /secret|password|token/i;
+    const auditFlags = {};
+    for (const [k, v] of Object.entries(ctx.flags)) {
+        auditFlags[k] = SECRET_FLAG_RE.test(k) ? "***" : v;
+    }
+    try {
+        await screen.cmd.run(ctx);
+        appendAuditEntry(state.profile || "default", {
+            group: screen.group.name,
+            command: screen.cmd.name,
+            positional: ctx.positional,
+            flags: auditFlags,
+            status: "ok",
+        });
+        const output = get();
+        // Try to generate ASCII art for BPMN XML output
+        if (output.type === "messages" && output.lines.length > 0) {
+            const xml = output.lines.join("\n");
+            if (xml.includes("<?xml") && (xml.includes("bpmn:") || xml.includes("definitions"))) {
+                try {
+                    const ascii = renderBpmnAscii(xml);
+                    output.altLines = ascii.split("\n");
+                }
+                catch {
+                    // ASCII rendering failed — no alt view
+                }
+            }
+        }
+        state.stack.push({
+            kind: "results",
+            group: screen.group,
+            cmd: screen.cmd,
+            output,
+            raw: rawCapture,
+            rawView: false,
+            curlView: false,
+            altView: false,
+            cursor: 0,
+            scroll: 0,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        appendAuditEntry(state.profile || "default", {
+            group: screen.group.name,
+            command: screen.cmd.name,
+            positional: ctx.positional,
+            flags: auditFlags,
+            status: "error",
+            error: msg,
+        });
+        screen.error = msg;
+    }
+    finally {
+        screen.running = false;
+    }
+}
+async function handleInputKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 9);
+    const field = screen.fields[screen.cursor];
+    // ── Edit mode ────────────────────────────────────────────────────────────
+    if (screen.editing && field && field.kind !== "run") {
+        const enumVals = getEnum(field);
+        const presets = getPresets(field);
+        // ── Enum field: only cycle, no free text ──────────────────────────────
+        if (enumVals) {
+            const idx = enumVals.indexOf(field.value);
+            switch (key) {
+                case "\x1b[A": // up — cycle backward
+                    field.value = enumVals[idx <= 0 ? enumVals.length - 1 : idx - 1] ?? field.value;
+                    break;
+                case "\x1b[B": // down — cycle forward
+                    field.value = enumVals[idx < 0 || idx >= enumVals.length - 1 ? 0 : idx + 1] ?? field.value;
+                    break;
+                case "\r":
+                case "\n":
+                    screen.editing = false;
+                    if (screen.cursor < screen.fields.length - 1) {
+                        screen.cursor++;
+                        if (screen.cursor >= screen.scroll + viewH)
+                            screen.scroll++;
+                    }
+                    break;
+                case "\x1b":
+                    screen.editing = false;
+                    break;
+            }
+            render(state);
+            return;
+        }
+        // ── Preset number field: ↑↓ cycle presets, free text still works ─────
+        if (presets) {
+            if (key === "\x1b[A") {
+                // up — previous preset (smaller)
+                const cur = Number(field.value);
+                const prev = [...presets].reverse().find((p) => p < cur) ?? presets[presets.length - 1];
+                if (prev !== undefined) {
+                    field.value = String(prev);
+                    field.cursor = field.value.length;
+                }
+                render(state);
+                return;
+            }
+            if (key === "\x1b[B") {
+                // down — next preset (larger)
+                const cur = Number(field.value);
+                const next = presets.find((p) => p > cur) ?? presets[0];
+                if (next !== undefined) {
+                    field.value = String(next);
+                    field.cursor = field.value.length;
+                }
+                render(state);
+                return;
+            }
+            // Fall through to normal text editing for all other keys
+        }
+        // ── Normal text editing ───────────────────────────────────────────────
+        switch (key) {
+            case "\r":
+            case "\n":
+                screen.editing = false;
+                if (screen.cursor < screen.fields.length - 1) {
+                    screen.cursor++;
+                    if (screen.cursor >= screen.scroll + viewH)
+                        screen.scroll++;
+                }
+                break;
+            case "\x1b":
+                screen.editing = false;
+                break;
+            case "\x1b[D": // left
+                if (field.cursor > 0)
+                    field.cursor--;
+                break;
+            case "\x1b[C": // right
+                if (field.cursor < field.value.length)
+                    field.cursor++;
+                break;
+            case "\x7f": // backspace
+                if (field.cursor > 0) {
+                    field.value = field.value.slice(0, field.cursor - 1) + field.value.slice(field.cursor);
+                    field.cursor--;
+                }
+                break;
+            case "\x1b[3~": // delete
+                field.value = field.value.slice(0, field.cursor) + field.value.slice(field.cursor + 1);
+                break;
+            case "\x01": // Ctrl+A / Home
+            case "\x1b[H":
+                field.cursor = 0;
+                break;
+            case "\x05": // Ctrl+E / End
+            case "\x1b[F":
+                field.cursor = field.value.length;
+                break;
+            case "\x0b": // Ctrl+K — clear to end
+                field.value = field.value.slice(0, field.cursor);
+                break;
+            case "\x15": // Ctrl+U — clear line
+                field.value = "";
+                field.cursor = 0;
+                break;
+            default: {
+                // Filter printable chars to support both single keypresses and pasted text
+                const printable = [...key].filter((ch) => ch >= " ").join("");
+                if (printable) {
+                    field.value =
+                        field.value.slice(0, field.cursor) + printable + field.value.slice(field.cursor);
+                    field.cursor += printable.length;
+                }
+            }
+        }
+        render(state);
+        return;
+    }
+    // ── Navigation mode ───────────────────────────────────────────────────────
+    switch (key) {
+        case "\x1b[A": // up
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B": // down
+            if (screen.cursor < screen.fields.length - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\r":
+        case "\n":
+            if (!field)
+                break;
+            if (field.kind === "run") {
+                if (screen.cmd.name === "worker") {
+                    launchWorkerView(screen, state);
+                }
+                else {
+                    await executeCommand(screen, state);
+                }
+            }
+            else if (isJsonField(field)) {
+                // Open the key-value JSON editor
+                const jsonFieldSpecs = field.kind === "flag" ? field.flagSpec?.fields : undefined;
+                state.stack.push({
+                    kind: "json-editor",
+                    group: screen.group,
+                    cmd: screen.cmd,
+                    fieldIndex: screen.cursor,
+                    fieldLabel: field.label,
+                    entries: buildInitialEntries(field.value, jsonFieldSpecs),
+                    fieldSpecs: jsonFieldSpecs,
+                    cursor: 0,
+                    col: "val",
+                    editing: false,
+                    scroll: 0,
+                    error: "",
+                });
+            }
+            else {
+                screen.editing = true;
+                // For enum fields, set to first value if currently empty
+                const enumVals = getEnum(field);
+                if (enumVals && !field.value)
+                    field.value = enumVals[0] ?? "";
+                field.cursor = field.value.length;
+            }
+            break;
+        case "\x1b[C": // right arrow also opens JSON editor
+            if (field && isJsonField(field)) {
+                const jsonFieldSpecs2 = field.kind === "flag" ? field.flagSpec?.fields : undefined;
+                state.stack.push({
+                    kind: "json-editor",
+                    group: screen.group,
+                    cmd: screen.cmd,
+                    fieldIndex: screen.cursor,
+                    fieldLabel: field.label,
+                    entries: buildInitialEntries(field.value, jsonFieldSpecs2),
+                    fieldSpecs: jsonFieldSpecs2,
+                    cursor: 0,
+                    col: "val",
+                    editing: false,
+                    scroll: 0,
+                    error: "",
+                });
+            }
+            break;
+        case "m":
+        case "M":
+            popToMain(state);
+            break;
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleResultsKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 10);
+    // r/R toggles raw view; u/U toggles curl view — mutually exclusive
+    if (key === "r" || key === "R") {
+        screen.rawView = !screen.rawView;
+        if (screen.rawView)
+            screen.curlView = false;
+        screen.scroll = 0;
+        render(state);
+        return;
+    }
+    if (key === "u" || key === "U") {
+        screen.curlView = !screen.curlView;
+        if (screen.curlView)
+            screen.rawView = false;
+        screen.scroll = 0;
+        render(state);
+        return;
+    }
+    if (screen.curlView) {
+        if (key === "y" || key === "Y") {
+            if (screen.raw) {
+                const { cmd } = buildCurlCmd(screen.raw);
+                copyToClipboard(cmd);
+            }
+        }
+        else if (key === "e" || key === "E") {
+            if (screen.raw) {
+                const { token } = buildCurlCmd(screen.raw);
+                if (token)
+                    copyToClipboard(`export ${CURL_TOKEN_VAR}="${token}"`);
+            }
+        }
+        else if (key === "\x1b[A") {
+            if (screen.scroll > 0)
+                screen.scroll--;
+        }
+        else if (key === "\x1b[B") {
+            screen.scroll++;
+        }
+        else if (key === "m" || key === "M") {
+            popToMain(state);
+        }
+        else if (key === "\x1b") {
+            state.stack.pop();
+        }
+        else if (key === "q" || key === "Q") {
+            done();
+            return;
+        }
+        render(state);
+        return;
+    }
+    if (screen.rawView) {
+        switch (key) {
+            case "\x1b[A":
+                if (screen.scroll > 0)
+                    screen.scroll--;
+                break;
+            case "\x1b[B":
+                screen.scroll++;
+                break;
+            case "m":
+            case "M":
+                popToMain(state);
+                break;
+            case "\x1b":
+                state.stack.pop();
+                break;
+            case "q":
+            case "Q":
+                done();
+                return;
+        }
+        render(state);
+        return;
+    }
+    if (screen.output.type !== "list") {
+        if (screen.output.type === "item") {
+            const entries = Object.entries(flattenObj(screen.output.data));
+            const expandArray = () => {
+                const entry = entries[screen.cursor];
+                if (entry) {
+                    const [fieldKey, v] = entry;
+                    if (v instanceof ArrayValue) {
+                        state.stack.push({
+                            kind: "detail",
+                            group: screen.group,
+                            item: v.items,
+                            label: `${fieldKey} (${v.items.length})`,
+                            cursor: 0,
+                            scroll: 0,
+                        });
+                    }
+                }
+            };
+            if (key === "\x1b[A" && screen.cursor > 0)
+                screen.cursor--;
+            else if (key === "\x1b[B" && screen.cursor < entries.length - 1)
+                screen.cursor++;
+            else if (key === " " || key === "\x1b[C")
+                expandArray();
+            else if (key === "\x1b[D")
+                state.stack.pop();
+            else if (key === "\x1b")
+                state.stack.pop();
+            else if (key === "m" || key === "M")
+                popToMain(state);
+            else if (key === "q" || key === "Q") {
+                done();
+                return;
+            }
+        }
+        else {
+            // messages type — scrollable + horizontal pan (screen.cursor = hOff)
+            const msgLines = screen.altView && screen.output.altLines ? screen.output.altLines : screen.output.lines;
+            switch (key) {
+                case "x":
+                case "X":
+                    if (screen.output.altLines) {
+                        screen.altView = !screen.altView;
+                        screen.scroll = 0;
+                        screen.cursor = 0;
+                    }
+                    break;
+                case "\x1b[A":
+                    if (screen.scroll > 0)
+                        screen.scroll = Math.max(0, screen.scroll - 3);
+                    break;
+                case "\x1b[B":
+                    screen.scroll = Math.min(Math.max(0, msgLines.length - viewH), screen.scroll + 3);
+                    break;
+                case "\x1b[C":
+                    if (!screen.altView)
+                        screen.cursor += 3;
+                    break;
+                case "\x1b[D":
+                    if (!screen.altView)
+                        screen.cursor = Math.max(0, screen.cursor - 3);
+                    break;
+                case "\x1b[5~":
+                    screen.scroll = Math.max(0, screen.scroll - viewH);
+                    break;
+                case "\x1b[6~":
+                    screen.scroll = Math.min(Math.max(0, msgLines.length - viewH), screen.scroll + viewH);
+                    break;
+                default:
+                    if (key === "\x1b")
+                        state.stack.pop();
+                    else if (key === "m" || key === "M")
+                        popToMain(state);
+                    else if (key === "q" || key === "Q") {
+                        done();
+                        return;
+                    }
+            }
+        }
+        render(state);
+        return;
+    }
+    const len = screen.output.items.length;
+    switch (key) {
+        case "\x1b[A": // up
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B": // down
+            if (screen.cursor < len - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\x1b[5~": // page up
+            screen.cursor = Math.max(0, screen.cursor - viewH);
+            screen.scroll = Math.max(0, screen.scroll - viewH);
+            break;
+        case "\x1b[6~": // page down
+            screen.cursor = Math.min(len - 1, screen.cursor + viewH);
+            screen.scroll = Math.min(Math.max(0, len - viewH), screen.scroll + viewH);
+            break;
+        case "\r":
+        case "\n": {
+            const item = screen.output.items[screen.cursor];
+            if (item) {
+                state.stack.push({
+                    kind: "detail",
+                    group: screen.group,
+                    item,
+                    label: "detail",
+                    cursor: 0,
+                    scroll: 0,
+                });
+            }
+            break;
+        }
+        case "f":
+        case "F": {
+            const item = screen.output.items[screen.cursor];
+            if (item && screen.cmd.relations) {
+                const resolved = [];
+                for (const rel of screen.cmd.relations) {
+                    const tGroup = state.groups.find((g) => g.name === rel.groupName);
+                    if (!tGroup)
+                        continue;
+                    const tCmd = tGroup.commands.find((c) => c.name === rel.commandName);
+                    if (!tCmd)
+                        continue;
+                    resolved.push({ group: tGroup, cmd: tCmd, params: rel.params });
+                }
+                if (resolved.length > 0) {
+                    state.stack.push({
+                        kind: "followup",
+                        sourceGroup: screen.group,
+                        item: item,
+                        relations: resolved,
+                        cursor: 0,
+                        scroll: 0,
+                    });
+                }
+            }
+            break;
+        }
+        case "m":
+        case "M":
+            popToMain(state);
+            break;
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleDetailKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 7);
+    const entries = Object.entries(flattenObj(screen.item));
+    const entryCount = entries.length;
+    switch (key) {
+        case "\x1b[A":
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B":
+            if (screen.cursor < entryCount - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\x1b[5~":
+            screen.cursor = Math.max(0, screen.cursor - viewH);
+            screen.scroll = Math.max(0, screen.scroll - viewH);
+            break;
+        case "\x1b[6~":
+            screen.cursor = Math.min(entryCount - 1, screen.cursor + viewH);
+            screen.scroll = Math.min(Math.max(0, entryCount - viewH), screen.scroll + viewH);
+            break;
+        case " ":
+        case "\x1b[C": {
+            const entry = entries[screen.cursor];
+            if (entry) {
+                const [fieldKey, v] = entry;
+                if (v instanceof ArrayValue) {
+                    state.stack.push({
+                        kind: "detail",
+                        group: screen.group,
+                        item: v.items,
+                        label: `${fieldKey} (${v.items.length})`,
+                        cursor: 0,
+                        scroll: 0,
+                    });
+                }
+            }
+            break;
+        }
+        case "\x1b[D":
+            state.stack.pop();
+            break;
+        case "m":
+        case "M":
+            popToMain(state);
+            break;
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleFollowupKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 8);
+    switch (key) {
+        case "\x1b[A":
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B":
+            if (screen.cursor < screen.relations.length - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\r":
+        case "\n": {
+            const rel = screen.relations[screen.cursor];
+            if (rel) {
+                const fields = buildFields(rel.cmd);
+                // Pre-fill args from the source item
+                for (const p of rel.params) {
+                    const val = String(screen.item[p.field] ?? "");
+                    const field = fields.find((f) => f.kind === "arg" && f.label === p.param);
+                    if (field) {
+                        field.value = val;
+                        field.cursor = val.length;
+                    }
+                }
+                const allFilled = fields.filter((f) => f.required).every((f) => f.value);
+                const runIdx = fields.findIndex((f) => f.kind === "run");
+                state.stack.push({
+                    kind: "input",
+                    group: rel.group,
+                    cmd: rel.cmd,
+                    fields,
+                    cursor: allFilled && runIdx >= 0 ? runIdx : 0,
+                    scroll: 0,
+                    editing: false,
+                    error: "",
+                    running: false,
+                });
+            }
+            break;
+        }
+        case "m":
+        case "M":
+            popToMain(state);
+            break;
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function saveJsonEditorToField(screen, state) {
+    const inputScreen = [...state.stack].reverse().find((s) => s.kind === "input");
+    if (inputScreen?.kind === "input") {
+        const field = inputScreen.fields[screen.fieldIndex];
+        if (field) {
+            field.value = entriesToJson(screen.entries);
+            field.cursor = field.value.length;
+        }
+    }
+}
+function handleJsonEditorKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 9);
+    const rowCount = screen.entries.length + 1;
+    const isAddRow = screen.cursor === screen.entries.length;
+    const entry = screen.entries[screen.cursor];
+    // ── Edit mode ────────────────────────────────────────────────────────────
+    if (screen.editing && entry) {
+        const activeIsKey = screen.col === "key";
+        const activeText = activeIsKey ? entry.key : entry.val;
+        const activeCursor = activeIsKey ? entry.keyCursor : entry.valCursor;
+        const setTextAndCursor = (text, cur) => {
+            if (activeIsKey) {
+                entry.key = text;
+                entry.keyCursor = cur;
+            }
+            else {
+                entry.val = text;
+                entry.valCursor = cur;
+            }
+        };
+        // Enum cycling for value column of a known enum field
+        const valSpec = !activeIsKey ? getFieldSpec(entry.key, screen.fieldSpecs) : undefined;
+        const enumVals = valSpec?.enum;
+        if (enumVals && enumVals.length > 0 && !activeIsKey) {
+            const curIdx = enumVals.indexOf(entry.val);
+            switch (key) {
+                case "\x1b[A": // up
+                    entry.val = enumVals[(curIdx - 1 + enumVals.length) % enumVals.length] ?? "";
+                    entry.valCursor = entry.val.length;
+                    render(state);
+                    return;
+                case "\x1b[B": // down
+                    entry.val = enumVals[(curIdx + 1) % enumVals.length] ?? "";
+                    entry.valCursor = entry.val.length;
+                    render(state);
+                    return;
+                case "\r":
+                case "\n":
+                    // If no value selected yet, pick first
+                    if (!entry.val && enumVals[0]) {
+                        entry.val = enumVals[0];
+                        entry.valCursor = entry.val.length;
+                    }
+                    screen.editing = false;
+                    screen.col = "key";
+                    if (screen.cursor < rowCount - 1) {
+                        screen.cursor++;
+                        if (screen.cursor >= screen.scroll + viewH)
+                            screen.scroll++;
+                    }
+                    render(state);
+                    return;
+                case "\x1b":
+                    screen.editing = false;
+                    render(state);
+                    return;
+                case "\t":
+                    screen.col = "key";
+                    render(state);
+                    return;
+            }
+        }
+        switch (key) {
+            case "\r":
+            case "\n":
+                screen.editing = false;
+                // Advance: key → val, then val → next row key
+                if (activeIsKey) {
+                    screen.col = "val";
+                }
+                else {
+                    screen.col = "key";
+                    if (screen.cursor < rowCount - 1) {
+                        screen.cursor++;
+                        if (screen.cursor >= screen.scroll + viewH)
+                            screen.scroll++;
+                    }
+                }
+                break;
+            case "\t": // Tab: switch key↔val
+                screen.col = activeIsKey ? "val" : "key";
+                break;
+            case "\x1b":
+                screen.editing = false;
+                break;
+            case "\x1b[D":
+                if (activeCursor > 0)
+                    setTextAndCursor(activeText, activeCursor - 1);
+                break;
+            case "\x1b[C":
+                if (activeCursor < activeText.length)
+                    setTextAndCursor(activeText, activeCursor + 1);
+                break;
+            case "\x7f":
+                if (activeCursor > 0) {
+                    setTextAndCursor(activeText.slice(0, activeCursor - 1) + activeText.slice(activeCursor), activeCursor - 1);
+                }
+                break;
+            case "\x01":
+            case "\x1b[H":
+                setTextAndCursor(activeText, 0);
+                break;
+            case "\x05":
+            case "\x1b[F":
+                setTextAndCursor(activeText, activeText.length);
+                break;
+            case "\x15":
+                setTextAndCursor("", 0);
+                break;
+            default: {
+                const printable = [...key].filter((ch) => ch >= " ").join("");
+                if (printable) {
+                    setTextAndCursor(activeText.slice(0, activeCursor) + printable + activeText.slice(activeCursor), activeCursor + printable.length);
+                }
+            }
+        }
+        render(state);
+        return;
+    }
+    // ── Navigation mode ───────────────────────────────────────────────────────
+    switch (key) {
+        case "\x1b[A": // up
+            if (screen.cursor > 0) {
+                screen.cursor--;
+                if (screen.cursor < screen.scroll)
+                    screen.scroll--;
+            }
+            break;
+        case "\x1b[B": // down
+            if (screen.cursor < rowCount - 1) {
+                screen.cursor++;
+                if (screen.cursor >= screen.scroll + viewH)
+                    screen.scroll++;
+            }
+            break;
+        case "\t": // Tab: switch key↔val (not on add-row)
+            if (!isAddRow)
+                screen.col = screen.col === "key" ? "val" : "key";
+            break;
+        case "\r":
+        case "\n":
+            if (isAddRow) {
+                // Add a new entry and start editing its key
+                screen.entries.push({ key: "", keyCursor: 0, val: "", valCursor: 0 });
+                screen.cursor = screen.entries.length - 1;
+                screen.col = "key";
+                screen.editing = true;
+            }
+            else {
+                // For known enum fields in val column, seed with first enum value
+                if (screen.col === "val" && entry) {
+                    const spec = getFieldSpec(entry.key, screen.fieldSpecs);
+                    if (spec?.enum && spec.enum.length > 0 && !entry.val) {
+                        entry.val = spec.enum[0] ?? "";
+                        entry.valCursor = entry.val.length;
+                    }
+                }
+                screen.editing = true;
+            }
+            break;
+        case "a":
+        case "A":
+            // Insert new entry after cursor and start editing
+            screen.entries.splice(screen.cursor + 1, 0, {
+                key: "",
+                keyCursor: 0,
+                val: "",
+                valCursor: 0,
+            });
+            screen.cursor = Math.min(screen.cursor + 1, screen.entries.length - 1);
+            screen.col = "key";
+            screen.editing = true;
+            break;
+        case "d":
+        case "D":
+            if (!isAddRow && screen.entries.length > 0) {
+                screen.entries.splice(screen.cursor, 1);
+                screen.cursor = Math.min(screen.cursor, screen.entries.length);
+            }
+            break;
+        case "\x1b":
+            saveJsonEditorToField(screen, state);
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            saveJsonEditorToField(screen, state);
+            done();
+            return;
+    }
+    render(state);
+}
+function handleProfileKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 7);
+    switch (key) {
+        case "\x1b[A":
+            if (screen.scroll > 0)
+                screen.scroll--;
+            break;
+        case "\x1b[B":
+            if (screen.scroll < Math.max(0, state.profileInfo.length - viewH))
+                screen.scroll++;
+            break;
+        case "p":
+        case "P":
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleSettingsKey(key, screen, state, done) {
+    screen.message = "";
+    if (screen.editing) {
+        if (key === "\r" || key === "\n") {
+            const row = SETTINGS_ROWS[screen.cursor];
+            if (row?.kind === "number") {
+                const n = Number(screen.editValue);
+                if (!Number.isNaN(n) && n >= row.min && n <= row.max) {
+                    saveSettings({ [row.key]: Math.floor(n) });
+                    screen.message = green(`✓ Saved: ${row.label} = ${Math.floor(n)}`);
+                }
+                else {
+                    screen.message = red(`Invalid — must be a number between ${row.min} and ${row.max}`);
+                }
+            }
+            screen.editing = false;
+            screen.editValue = "";
+        }
+        else if (key === "\x1b") {
+            screen.editing = false;
+            screen.editValue = "";
+        }
+        else if (key === "\x7f" || key === "\x08") {
+            screen.editValue = screen.editValue.slice(0, -1);
+        }
+        else if (key >= "0" && key <= "9") {
+            screen.editValue += key;
+        }
+        render(state);
+        return;
+    }
+    switch (key) {
+        case "\x1b[A":
+            if (screen.cursor > 0)
+                screen.cursor--;
+            break;
+        case "\x1b[B":
+            if (screen.cursor < SETTINGS_ROWS.length - 1)
+                screen.cursor++;
+            break;
+        case "\r":
+        case "\n": {
+            const row = SETTINGS_ROWS[screen.cursor];
+            if (row?.kind === "number") {
+                screen.editing = true;
+                screen.editValue = String(getSettings()[row.key]);
+            }
+            else if (row?.kind === "action" && row.id === "show-audit-log") {
+                state.stack.push({ kind: "audit-log", scroll: 0 });
+            }
+            break;
+        }
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleAuditLogKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 8);
+    const total = getAuditLog(state.profile || undefined).length;
+    switch (key) {
+        case "\x1b[A":
+            if (screen.scroll > 0)
+                screen.scroll--;
+            break;
+        case "\x1b[B":
+            if (screen.scroll < Math.max(0, total - viewH))
+                screen.scroll++;
+            break;
+        case "\x1b":
+            state.stack.pop();
+            break;
+        case "q":
+        case "Q":
+            done();
+            return;
+    }
+    render(state);
+}
+function handleWorkerKey(key, screen, state, done) {
+    const { rows } = termSize();
+    const viewH = Math.max(3, rows - 13);
+    const isRunning = screen.status === "running" || screen.status === "starting";
+    switch (key) {
+        case "\x1b[A": // up
+            screen.autoScroll = false;
+            if (screen.scroll > 0)
+                screen.scroll--;
+            break;
+        case "\x1b[B": // down
+            if (screen.scroll < Math.max(0, screen.log.length - viewH)) {
+                screen.scroll++;
+                if (screen.scroll >= screen.log.length - viewH)
+                    screen.autoScroll = true;
+            }
+            break;
+        case "\x1b[5~": // page up
+            screen.autoScroll = false;
+            screen.scroll = Math.max(0, screen.scroll - viewH);
+            break;
+        case "\x1b[6~": // page down
+            screen.scroll = Math.min(Math.max(0, screen.log.length - viewH), screen.scroll + viewH);
+            break;
+        case "a":
+        case "A":
+            screen.autoScroll = !screen.autoScroll;
+            if (screen.autoScroll)
+                screen.scroll = Math.max(0, screen.log.length - viewH);
+            break;
+        case "s":
+        case "S":
+            if (isRunning && screen._stop)
+                screen._stop();
+            break;
+        case "\x1b": // esc — only go back when stopped
+            if (!isRunning) {
+                stopWorkerScreen(screen);
+                state.stack.pop();
+            }
+            break;
+        case "m":
+        case "M":
+            if (!isRunning) {
+                stopWorkerScreen(screen);
+                popToMain(state);
+            }
+            break;
+        case "q":
+        case "Q":
+            if (isRunning && screen._stop)
+                screen._stop();
+            stopWorkerScreen(screen);
+            done();
+            return;
+    }
+    render(state);
+}
+async function handleKey(key, state, done) {
+    if (state.quitting)
+        return;
+    if (key === "\x03") {
+        done();
+        return;
+    }
+    const screen = state.stack[state.stack.length - 1];
+    if (!screen)
+        return;
+    // Global p/P: open profile view (skip when actively editing text)
+    if (key === "p" || key === "P") {
+        const isEditing = (screen.kind === "input" && screen.editing) ||
+            (screen.kind === "json-editor" && screen.editing) ||
+            (screen.kind === "settings" && screen.editing);
+        const isProfile = screen.kind === "profile";
+        if (!isEditing && !isProfile) {
+            state.stack.push({ kind: "profile", scroll: 0 });
+            render(state);
+            return;
+        }
+    }
+    switch (screen.kind) {
+        case "main":
+            handleMainKey(key, screen, state, done);
+            break;
+        case "commands":
+            handleCommandsKey(key, screen, state, done);
+            break;
+        case "input":
+            await handleInputKey(key, screen, state, done);
+            break;
+        case "results":
+            handleResultsKey(key, screen, state, done);
+            break;
+        case "detail":
+            handleDetailKey(key, screen, state, done);
+            break;
+        case "followup":
+            handleFollowupKey(key, screen, state, done);
+            break;
+        case "profile":
+            handleProfileKey(key, screen, state, done);
+            break;
+        case "settings":
+            handleSettingsKey(key, screen, state, done);
+            break;
+        case "audit-log":
+            handleAuditLogKey(key, screen, state, done);
+            break;
+        case "worker":
+            handleWorkerKey(key, screen, state, done);
+            break;
+        case "json-editor":
+            handleJsonEditorKey(key, screen, state, done);
+            break;
+    }
+}
+// ─── Shared TUI runner ────────────────────────────────────────────────────────
+async function startTui(state) {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        // Non-interactive fallback: print group list or group commands
+        const first = state.stack[0];
+        if (first?.kind === "commands") {
+            process.stdout.write(`${first.group.name}: ${first.group.description}\n`);
+            process.stdout.write(`Commands: ${first.group.commands.map((c) => c.name).join(", ")}\n`);
+        }
+        else {
+            for (const g of state.groups) {
+                process.stdout.write(`${g.name.padEnd(24)} ${g.description}\n`);
+            }
+        }
+        return;
+    }
+    process.stdout.write(`${ALT_ON}${HIDE}`);
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        process.stdout.write(`${ALT_OFF}${SHOW}`);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    };
+    process.on("exit", cleanup);
+    render(state);
+    await new Promise((resolve) => {
+        const done = () => {
+            state.quitting = true;
+            resolve();
+        };
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        let handling = false;
+        process.stdin.on("data", async (key) => {
+            if (handling || state.quitting)
+                return;
+            handling = true;
+            try {
+                await handleKey(key, state, done);
+            }
+            finally {
+                handling = false;
+            }
+        });
+    });
+    cleanup();
+    process.removeListener("exit", cleanup);
+}
+/** Open the TUI at the top-level main menu listing all command groups. */
+export async function runMainTui(groups, getClient, getAdminClient, opts) {
+    return startTui({
+        groups,
+        stack: [{ kind: "main", cursor: 0, scroll: 0, search: "" }],
+        getClient,
+        getAdminClient: getAdminClient ??
+            opts?.getAdminClient ??
+            (() => Promise.reject(new Error("No admin client"))),
+        quitting: false,
+        profile: opts?.profile ?? "",
+        profileInfo: opts?.profileInfo ?? [],
+    });
+}
+/**
+ * Open the TUI directly at a specific group's command list.
+ * The main menu is placed at the bottom of the stack so `m` always works.
+ */
+export async function runGroupTui(group, groups, getClient, getAdminClient, opts) {
+    const cursor = groups.findIndex((g) => g.name === group.name);
+    return startTui({
+        groups,
+        stack: [
+            { kind: "main", cursor: Math.max(0, cursor), scroll: 0, search: "" },
+            { kind: "commands", group, cursor: 0, search: "" },
+        ],
+        getClient,
+        getAdminClient: getAdminClient ??
+            opts?.getAdminClient ??
+            (() => Promise.reject(new Error("No admin client"))),
+        quitting: false,
+        profile: opts?.profile ?? "",
+        profileInfo: opts?.profileInfo ?? [],
+    });
+}
+//# sourceMappingURL=tui.js.map