@quintinshaw/pi-dynamic-workflows 1.9.1 → 1.9.2

package/README.md

@@ -25,7 +25,8 @@ Inspired by Anthropic's [dynamic workflows in Claude Code](https://claude.com/bl
 - 🌲 **Git worktree isolation** — `isolation: "worktree"` gives an agent its own branch so parallel agents can edit the same files without clobbering each other.
 - 🔭 **Bundled `/deep-research`** — fans out **real** web searches, fetches sources, keeps only multi-source-supported claims, and writes a cited report. Plus `/adversarial-review` for skeptic-vetted findings.
 - 🧩 **Saved & nested workflows** — turn any run into a `/<name>` slash command; compose saved workflows from inside other scripts.
-- 🪟 **Background + live task panel** — run workflows in the background, watch a "Workflows running" panel under your input, and get the result delivered back into the chat when it finishes.
+- 🪟 **Non-blocking by default + live task panel** — workflows run in the background: the turn ends immediately so you can keep chatting or start other tasks, a "Workflows running" panel tracks them under your input, and when one finishes its result is delivered back and the conversation **auto-continues** (queued politely after whatever you're doing, never interrupting).
+- 🌈 **Workflows mode in the input box** — type `workflow`/`workflows` and the word turns into a flowing rainbow, arming a forced workflow for that message. One Backspace right after the word disarms it (turns plain white) without deleting it.
 
 > **This is a heavily extended fork.** The [upstream project](https://github.com/Michaelliv/pi-dynamic-workflows) shipped the core script runtime; here, every advertised capability is actually **implemented, real-tested against the Pi SDK, and shipped** — see the [comparison](#whats-different-from-upstream) below.
 
@@ -56,7 +57,7 @@ Just ask for a workflow in plain language:
 Run a workflow to audit every route under src/routes/ for missing auth checks.
 ```
 
-Pi writes the script and streams compact progress inline:
+Pi writes the script and runs it in the background — your turn ends right away, and a compact progress view streams in the "Workflows running" task panel while you keep working:
 
 ```text
 ◆ Workflow: auth_audit (5/5 done · 48,210 tokens · $0.0131)
@@ -70,7 +71,7 @@ Pi writes the script and streams compact progress inline:
     #5 ✓ adversarial recheck
 ```
 
-Press `Esc` to cancel; active subagents are aborted and surfaced as skipped.
+When it finishes, the result is delivered back into the conversation and the turn auto-continues — queued after whatever you're doing so it never interrupts. (Need the result inline in the same turn instead? The model can pass `background: false` to block.)
 
 ## What's different from upstream
 
@@ -88,7 +89,7 @@ This fork turns the original's roadmap into working, tested features:
 | **`/deep-research` with real web access** | — | ✅ live search + cross-checking |
 | **Saved workflows as `/<name>`** | — | ✅ |
 | **Nested `workflow()`** | — | ✅ shares the global caps |
-| **Background runs + live task panel + result delivery** | — | ✅ |
+| **Non-blocking background runs + live task panel + auto-continue delivery** | — | ✅ |
 | Test suite | minimal | ✅ 43 tests + real Pi end-to-end |
 
 <sub>*Upstream injected the requested model as a text line in the prompt; it never changed the subagent's actual model.</sub>
@@ -105,7 +106,11 @@ This fork turns the original's roadmap into working, tested features:
 /adversarial-review <task> # findings cross-checked by skeptical reviewers
 ```
 
-In the **interactive navigator**: `↑/↓` (or `j/k`) select · `enter`/`→` open · `esc`/`←` back · `j/k` scroll detail · `p` pause/resume · `x` stop · `s` save · `q` quit.
+In the **interactive navigator**: `↑/↓` (or `j/k`) select · `enter`/`→` open · `esc`/`←` back · `j/k` scroll detail · `p` pause · `x` stop · `r` restart (re-runs the whole workflow as a fresh background run) · `s` save · `q` quit. The agents list and each agent's detail show **which model it ran on**.
+
+### Workflows mode (input box)
+
+As you type, the words `workflow`/`workflows` light up as a **flowing rainbow** — a signal that submitting this message will deliberately run a workflow (the message is rewritten to ask Pi to orchestrate subagents rather than answer directly). Changed your mind? Press **Backspace** once right after the word: it turns plain white (disarmed) without being deleted. Type a fresh trigger word to re-arm. Slash commands like `/workflows` are left alone (never highlighted). Everything else about the editor — history, autocomplete, paste, multiline — is unchanged.
 
 ## Writing a workflow
 
@@ -152,7 +157,9 @@ return { inventory, summary }
 | `isolation` | `"worktree"` | Run this agent in its own throwaway git worktree (parallel edits without conflict) |
 | `timeoutMs` | number | Override the default 5-minute agent timeout |
 
-Models can also be set per phase via `meta.phases[].model`. Precedence: `opts.model` > phase model > session default; an unknown model logs a warning and falls back.
+Models can also be set per phase via `meta.phases[].model`. Precedence: `opts.model` > phase model > session default; an unknown model logs a warning and falls back. The model each agent ran on is recorded and shown in the `/workflows` navigator.
+
+**Model routing is decided by the assistant, not hardcoded.** When it writes a workflow, Pi is given the routing policy and the list of your currently authenticated models, and picks each agent's `model` accordingly: a lighter same-family model (one tier below your main model — e.g. Claude→Haiku, GPT→a mini) for exploration/search/gathering agents, and your main model for analysis/judgment/decision agents. If you name a specific model, that wins.
 
 ### Structured output
 

package/dist/agent.d.ts

@@ -9,6 +9,12 @@ export interface WorkflowAgentOptions {
     /** Extra system guidance prepended to every subagent task. */
     instructions?: string;
 }
+/**
+ * List the user's currently available models (those with auth configured) as
+ * `provider/modelId` specs. Used to tell the workflow author which models it may
+ * route agents to. Best-effort: returns [] if the registry can't be built.
+ */
+export declare function listAvailableModelSpecs(): string[];
 /** Real token/cost usage for a single subagent run, read from the SDK session. */
 export interface AgentUsage {
     input: number;

package/dist/agent.js

@@ -1,6 +1,22 @@
 import { join } from "node:path";
 import { AuthStorage, createAgentSession, createCodingTools, getAgentDir, ModelRegistry, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { createStructuredOutputTool } from "./structured-output.js";
+/**
+ * List the user's currently available models (those with auth configured) as
+ * `provider/modelId` specs. Used to tell the workflow author which models it may
+ * route agents to. Best-effort: returns [] if the registry can't be built.
+ */
+export function listAvailableModelSpecs() {
+    try {
+        const dir = getAgentDir();
+        const auth = AuthStorage.create(join(dir, "auth.json"));
+        const registry = ModelRegistry.create(auth, join(dir, "models.json"));
+        return registry.getAvailable().map((m) => `${m.provider}/${m.id}`);
+    }
+    catch {
+        return [];
+    }
+}
 export class WorkflowAgent {
     cwd;
     baseTools;

package/dist/display.d.ts

@@ -11,6 +11,8 @@ export interface WorkflowAgentSnapshot {
     error?: string;
     /** Tokens used by this agent. */
     tokens?: number;
+    /** The model this agent ran on (provider/id), when known. */
+    model?: string;
 }
 export interface WorkflowSnapshot {
     name: string;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type { AdversarialReviewConfig } from "./adversarial-review.js";
 export { generateAdversarialReviewWorkflow, generateMultiPerspectiveWorkflow } from "./adversarial-review.js";
 export type { AgentRunOptions, AgentRunResult, WorkflowAgentOptions } from "./agent.js";
-export { WorkflowAgent } from "./agent.js";
+export { listAvailableModelSpecs, WorkflowAgent } from "./agent.js";
 export type { AutoWorkflowConfig } from "./auto-workflow.js";
 export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
 export { registerBuiltinWorkflows } from "./builtin-commands.js";
@@ -25,12 +25,13 @@ export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-t
 export type { AgentOptions, JournalEntry, SharedRuntime, WorkflowMeta, WorkflowMetaPhase, WorkflowRunOptions, WorkflowRunResult, } from "./workflow.js";
 export { parseWorkflowScript, runWorkflow } from "./workflow.js";
 export { registerWorkflowCommands } from "./workflow-commands.js";
+export { buildForcedWorkflowPrompt, colorizeWorkflow, endsWithTrigger, hasTrigger, installWorkflowEditor, RAINBOW, tokenizeAnsi, WorkflowEditor, type WorkflowModeState, } from "./workflow-editor.js";
 export type { ManagedRun, WorkflowManagerOptions } from "./workflow-manager.js";
 export { WorkflowManager } from "./workflow-manager.js";
 export type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
 export { createWorkflowStorage } from "./workflow-saved.js";
 export type { WorkflowToolInput, WorkflowToolOptions } from "./workflow-tool.js";
-export { createWorkflowTool } from "./workflow-tool.js";
+export { backgroundStartedText, createWorkflowTool } from "./workflow-tool.js";
 export { keyToAction, type NavAction, NavigatorModel, NavigatorState, openWorkflowNavigator, renderNavigator, type ViewKind, } from "./workflow-ui.js";
 export type { Worktree } from "./worktree.js";
 export { createWorktree, removeWorktree } from "./worktree.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { generateAdversarialReviewWorkflow, generateMultiPerspectiveWorkflow } from "./adversarial-review.js";
-export { WorkflowAgent } from "./agent.js";
+export { listAvailableModelSpecs, WorkflowAgent } from "./agent.js";
 export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
 export { registerBuiltinWorkflows } from "./builtin-commands.js";
 export * from "./config.js";
@@ -15,8 +15,9 @@ export { installResultDelivery, installTaskPanel } from "./task-panel.js";
 export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";
 export { parseWorkflowScript, runWorkflow } from "./workflow.js";
 export { registerWorkflowCommands } from "./workflow-commands.js";
+export { buildForcedWorkflowPrompt, colorizeWorkflow, endsWithTrigger, hasTrigger, installWorkflowEditor, RAINBOW, tokenizeAnsi, WorkflowEditor, } from "./workflow-editor.js";
 export { WorkflowManager } from "./workflow-manager.js";
 export { createWorkflowStorage } from "./workflow-saved.js";
-export { createWorkflowTool } from "./workflow-tool.js";
+export { backgroundStartedText, createWorkflowTool } from "./workflow-tool.js";
 export { keyToAction, NavigatorModel, NavigatorState, openWorkflowNavigator, renderNavigator, } from "./workflow-ui.js";
 export { createWorktree, removeWorktree } from "./worktree.js";

package/dist/run-persistence.d.ts

@@ -12,6 +12,8 @@ export interface PersistedAgentState {
     error?: string;
     startedAt?: string;
     endedAt?: string;
+    /** The model this agent ran on (provider/id), when known. */
+    model?: string;
 }
 export interface PersistedRunState {
     runId: string;

package/dist/task-panel.d.ts

@@ -1,7 +1,7 @@
 /**
  * Background-run UX, mirroring Claude Code:
  *  - A live task panel below the input lists in-progress runs while you keep working.
- *    Focus it (↓) and press enter to open the full navigator.
+ *    It is informational; run /workflows to open the full navigator.
  *  - When a background run finishes, its result is delivered back into the
  *    conversation so the paused task continues with the outcome.
  */
@@ -13,12 +13,21 @@ export interface TaskPanelOptions {
     cwd?: string;
 }
 /**
- * Deliver a background run's result into the conversation when it completes or
- * fails. Set up once per extension; idempotent via an internal guard.
+ * When a background run finishes (or fails), deliver its result back into the
+ * conversation AND continue the turn so the assistant can act on it — without
+ * blocking the user meanwhile:
+ *
+ *  - `triggerTurn: true` starts a fresh turn when the agent is idle, feeding the
+ *    result to the model so the paused conversation continues.
+ *  - `deliverAs: "followUp"` means that if the user is busy in another turn, the
+ *    result is queued and picked up after that turn finishes — never interrupting.
+ *
+ * Set up once per extension; idempotent via an internal guard.
  */
 export declare function installResultDelivery(pi: ExtensionAPI, manager: WorkflowManager): void;
 /**
  * Install the live "workflows running" panel below the editor. Re-rendered on
- * every manager event; focus + enter opens the navigator.
+ * every manager event. Informational only — the user opens the navigator with
+ * /workflows. (`_pi`/`_opts` are kept for signature stability.)
  */
-export declare function installTaskPanel(pi: ExtensionAPI, manager: WorkflowManager, ui: ExtensionUIContext, opts?: TaskPanelOptions): void;
+export declare function installTaskPanel(_pi: ExtensionAPI, manager: WorkflowManager, ui: ExtensionUIContext, _opts?: TaskPanelOptions): void;

package/dist/task-panel.js

@@ -1,42 +1,56 @@
 /**
  * Background-run UX, mirroring Claude Code:
  *  - A live task panel below the input lists in-progress runs while you keep working.
- *    Focus it (↓) and press enter to open the full navigator.
+ *    It is informational; run /workflows to open the full navigator.
  *  - When a background run finishes, its result is delivered back into the
  *    conversation so the paused task continues with the outcome.
  */
-import { parseKey } from "@earendil-works/pi-tui";
-import { openWorkflowNavigator } from "./workflow-ui.js";
 const RUN_EVENTS = ["agentStart", "agentEnd", "phase", "log", "complete", "error", "stopped", "paused", "resumed"];
 function deliverText(run) {
     const r = run.result?.result;
     const body = r && typeof r.report === "string" && r.report.trim() ? r.report : JSON.stringify(run.result?.result, null, 2);
     const tokens = run.result?.tokenUsage ? ` · ${run.result.tokenUsage.total.toLocaleString()} tokens` : "";
     const agents = run.result?.agentCount ?? run.snapshot.agentCount;
-    return `✓ Workflow "${run.snapshot.name}" finished (${agents} agents${tokens}).\n\n${body}`;
+    return [
+        `✓ Background workflow "${run.snapshot.name}" finished (${agents} agents${tokens}).`,
+        "Continue helping the user based on this result.",
+        "",
+        body,
+    ].join("\n");
 }
 /**
- * Deliver a background run's result into the conversation when it completes or
- * fails. Set up once per extension; idempotent via an internal guard.
+ * When a background run finishes (or fails), deliver its result back into the
+ * conversation AND continue the turn so the assistant can act on it — without
+ * blocking the user meanwhile:
+ *
+ *  - `triggerTurn: true` starts a fresh turn when the agent is idle, feeding the
+ *    result to the model so the paused conversation continues.
+ *  - `deliverAs: "followUp"` means that if the user is busy in another turn, the
+ *    result is queued and picked up after that turn finishes — never interrupting.
+ *
+ * Set up once per extension; idempotent via an internal guard.
  */
 export function installResultDelivery(pi, manager) {
     if (manager.__deliveryInstalled)
         return;
     manager.__deliveryInstalled = true;
+    const deliver = (content) => {
+        void pi.sendMessage({ customType: "workflow-result", content, display: true }, { triggerTurn: true, deliverAs: "followUp" });
+    };
     manager.on("complete", ({ runId }) => {
         const run = manager.getRun(runId);
-        if (run)
-            void pi.sendMessage({ customType: "workflow-result", content: deliverText(run), display: true });
+        // Only background/resumed runs are delivered: a foreground (sync) run already
+        // returns its result inline as the tool result, so re-delivering would dup it.
+        if (run?.background)
+            deliver(deliverText(run));
     });
     manager.on("error", ({ runId, error }) => {
-        void pi.sendMessage({
-            customType: "workflow-result",
-            content: `✗ Workflow ${runId} failed: ${error?.message ?? "unknown error"}`,
-            display: true,
-        });
+        if (!manager.getRun(runId)?.background)
+            return;
+        deliver(`✗ Background workflow ${runId} failed: ${error?.message ?? "unknown error"}`);
     });
 }
-function renderPanel(manager, theme, focused) {
+function renderPanel(manager, theme) {
     const active = manager.listRuns().filter((r) => r.status === "running" || r.status === "paused");
     if (!active.length)
         return [];
@@ -48,29 +62,23 @@ function renderPanel(manager, theme, focused) {
         const phase = live?.snapshot.currentPhase ? ` · ${live.snapshot.currentPhase}` : "";
         return `  ${icon} ${r.workflowName}  ${done}/${agents.length} agents${phase}`;
     });
-    const hint = focused
-        ? theme.fg("accent", "  enter: open · esc: back")
-        : theme.fg("dim", "  ↓ then enter, or /workflows, to open");
+    const hint = theme.fg("dim", "  run /workflows to open");
     return [theme.bold(`Workflows running (${active.length}):`), ...rows, hint];
 }
 /**
  * Install the live "workflows running" panel below the editor. Re-rendered on
- * every manager event; focus + enter opens the navigator.
+ * every manager event. Informational only — the user opens the navigator with
+ * /workflows. (`_pi`/`_opts` are kept for signature stability.)
  */
-export function installTaskPanel(pi, manager, ui, opts = {}) {
+export function installTaskPanel(_pi, manager, ui, _opts = {}) {
     ui.setWidget("workflow-tasks", (tui, theme) => {
         const onEvent = () => tui.requestRender();
         for (const ev of RUN_EVENTS)
             manager.on(ev, onEvent);
+        // Purely informational: it lists running runs and re-renders on events. To
+        // open the navigator, the user runs /workflows (the panel takes no input).
         const comp = {
-            focused: false,
-            render: () => renderPanel(manager, theme, comp.focused ?? false),
-            handleInput: (data) => {
-                const key = parseKey(data);
-                if (key === "enter" || key === "return" || key === "right") {
-                    void openWorkflowNavigator(pi, manager, ui, opts);
-                }
-            },
+            render: () => renderPanel(manager, theme),
             invalidate: () => { },
             dispose: () => {
                 for (const ev of RUN_EVENTS)

package/dist/workflow-editor.d.ts

@@ -0,0 +1,74 @@
+/**
+ * "Workflows mode" input affordance, à la a smart input box:
+ *
+ *  - While the editor text contains the word `workflow`/`workflows`, those letters
+ *    render as a flowing rainbow, signalling that submitting will engage a workflow.
+ *  - Pressing Backspace immediately after such a word toggles the highlight OFF
+ *    (the word stays, but turns plain white) — a non-destructive "don't run a
+ *    workflow after all". Re-typing a fresh trigger word turns it back on.
+ *  - When the highlight is ON at submit time, the user's message is transformed to
+ *    instruct Pi to actually run the workflow tool.
+ *
+ * Implementation: we replace the core editor with a thin subclass of the exported
+ * `CustomEditor` (which itself extends pi-tui's `Editor`), overriding only
+ * `render()` (to colorize) and `handleInput()` (for the Backspace toggle). All
+ * other editor behavior — history, autocomplete, paste, undo, multiline — is
+ * inherited untouched.
+ */
+import { CustomEditor, type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
+/** 256-color ring cycling through the spectrum — shifted by a tick to "flow". */
+export declare const RAINBOW: number[];
+export declare function hasTrigger(text: string): boolean;
+export declare function endsWithTrigger(textBeforeCursor: string): boolean;
+/** Shared, mutable view of whether "workflows mode" is currently armed. */
+export interface WorkflowModeState {
+    active: boolean;
+}
+interface AnsiToken {
+    esc?: string;
+    ch?: string;
+}
+/**
+ * Split a rendered line into ANSI-escape tokens (passed through verbatim) and
+ * single visible-character tokens. Handles CSI sequences (`\x1b[…m`, e.g. the
+ * cursor's inverse-video) and APC/OSC string sequences (e.g. the zero-width
+ * `CURSOR_MARKER` = `\x1b_pi:c\x07`) so colorization never corrupts them.
+ */
+export declare function tokenizeAnsi(line: string): AnsiToken[];
+/**
+ * Colorize every `workflow`/`workflows` occurrence in a rendered line with a
+ * flowing rainbow, leaving all ANSI escapes (cursor, markers) intact. Returns the
+ * line unchanged when it contains no trigger.
+ */
+export declare function colorizeWorkflow(line: string, tick: number, palette?: number[]): string;
+/**
+ * Editor that paints the trigger words and owns the on/off toggle. Reads/writes
+ * `state.active` so the extension's `input` handler can decide whether to force a
+ * workflow at submit time.
+ */
+export declare class WorkflowEditor extends CustomEditor {
+    private readonly modeState;
+    private tick;
+    private timer?;
+    /** Toggled off by Backspace-after-word; re-armed when a fresh trigger appears. */
+    private disabled;
+    private wasTriggered;
+    constructor(tui: TUI, theme: EditorTheme, keybindings: ConstructorParameters<typeof CustomEditor>[2], modeState: WorkflowModeState);
+    /** Highlighted/armed: a trigger is present and the user hasn't toggled it off. */
+    isActive(): boolean;
+    handleInput(data: string): void;
+    render(width: number): string[];
+    /** Absolute text before the cursor, used to detect "right after the word". */
+    private cursorAfterTrigger;
+    private syncState;
+    private reconcileAnimation;
+}
+/** The directive appended to a submitted message when workflows mode is armed. */
+export declare function buildForcedWorkflowPrompt(text: string): string;
+/**
+ * Install the workflows-mode editor and the submit-time forcing hook.
+ * Call once with the UI context (e.g. in `session_start`).
+ */
+export declare function installWorkflowEditor(pi: ExtensionAPI, ui: ExtensionUIContext): WorkflowModeState;
+export {};

package/dist/workflow-editor.js

@@ -0,0 +1,228 @@
+/**
+ * "Workflows mode" input affordance, à la a smart input box:
+ *
+ *  - While the editor text contains the word `workflow`/`workflows`, those letters
+ *    render as a flowing rainbow, signalling that submitting will engage a workflow.
+ *  - Pressing Backspace immediately after such a word toggles the highlight OFF
+ *    (the word stays, but turns plain white) — a non-destructive "don't run a
+ *    workflow after all". Re-typing a fresh trigger word turns it back on.
+ *  - When the highlight is ON at submit time, the user's message is transformed to
+ *    instruct Pi to actually run the workflow tool.
+ *
+ * Implementation: we replace the core editor with a thin subclass of the exported
+ * `CustomEditor` (which itself extends pi-tui's `Editor`), overriding only
+ * `render()` (to colorize) and `handleInput()` (for the Backspace toggle). All
+ * other editor behavior — history, autocomplete, paste, undo, multiline — is
+ * inherited untouched.
+ */
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+// A trigger is `workflow`/`workflows` (substring, case-insensitive) that is NOT
+// immediately preceded by `/` — so a slash command like `/workflows` or `/workflow`
+// is left alone (not colored, not armed).
+/** Matches a trigger anywhere in the text. */
+const TRIGGER = /(?<!\/)workflows?/i;
+/** Global variant for finding every occurrence to colorize. */
+const TRIGGER_G = /(?<!\/)workflows?/gi;
+/** True when the text immediately before the cursor ends with a trigger word. */
+const TRIGGER_AT_END = /(?<!\/)workflows?$/i;
+/** 256-color ring cycling through the spectrum — shifted by a tick to "flow". */
+export const RAINBOW = [
+    196, 160, 202, 166, 208, 172, 214, 178, 220, 184, 226, 190, 118, 82, 46, 47, 48, 49, 50, 51, 45, 39, 33, 27, 21, 57,
+    93, 129, 165, 201, 198, 197,
+];
+export function hasTrigger(text) {
+    return TRIGGER.test(text);
+}
+export function endsWithTrigger(textBeforeCursor) {
+    return TRIGGER_AT_END.test(textBeforeCursor);
+}
+/**
+ * Split a rendered line into ANSI-escape tokens (passed through verbatim) and
+ * single visible-character tokens. Handles CSI sequences (`\x1b[…m`, e.g. the
+ * cursor's inverse-video) and APC/OSC string sequences (e.g. the zero-width
+ * `CURSOR_MARKER` = `\x1b_pi:c\x07`) so colorization never corrupts them.
+ */
+export function tokenizeAnsi(line) {
+    const tokens = [];
+    let i = 0;
+    while (i < line.length) {
+        if (line[i] === "\x1b") {
+            let j = i + 1;
+            const next = line[j];
+            if (next === "[") {
+                // CSI: ends at a final byte in 0x40–0x7e.
+                j++;
+                while (j < line.length && !(line[j] >= "@" && line[j] <= "~"))
+                    j++;
+                j++;
+            }
+            else if (next === "]" || next === "_" || next === "P" || next === "^") {
+                // String sequence: ends at BEL (\x07) or ST (\x1b\\).
+                j++;
+                while (j < line.length && line[j] !== "\x07" && !(line[j] === "\x1b" && line[j + 1] === "\\"))
+                    j++;
+                if (line[j] === "\x07")
+                    j++;
+                else if (line[j] === "\x1b")
+                    j += 2;
+            }
+            else {
+                j++; // lone ESC + one byte
+            }
+            tokens.push({ esc: line.slice(i, j) });
+            i = j;
+        }
+        else {
+            tokens.push({ ch: line[i] });
+            i++;
+        }
+    }
+    return tokens;
+}
+/**
+ * Colorize every `workflow`/`workflows` occurrence in a rendered line with a
+ * flowing rainbow, leaving all ANSI escapes (cursor, markers) intact. Returns the
+ * line unchanged when it contains no trigger.
+ */
+export function colorizeWorkflow(line, tick, palette = RAINBOW) {
+    const tokens = tokenizeAnsi(line);
+    const visible = tokens
+        .filter((t) => t.ch !== undefined)
+        .map((t) => t.ch)
+        .join("");
+    if (!TRIGGER.test(visible))
+        return line;
+    const ranges = [];
+    TRIGGER_G.lastIndex = 0;
+    for (let m = TRIGGER_G.exec(visible); m; m = TRIGGER_G.exec(visible)) {
+        ranges.push([m.index, m.index + m[0].length]);
+    }
+    const inRange = (idx) => ranges.some(([s, e]) => idx >= s && idx < e);
+    let out = "";
+    let vi = 0;
+    for (const t of tokens) {
+        if (t.esc !== undefined) {
+            out += t.esc;
+            continue;
+        }
+        if (inRange(vi)) {
+            const color = palette[(vi + tick) % palette.length];
+            // Reset only the foreground (39) afterwards so a surrounding inverse-video
+            // (the cursor) is preserved.
+            out += `\x1b[38;5;${color}m${t.ch}\x1b[39m`;
+        }
+        else {
+            out += t.ch ?? "";
+        }
+        vi++;
+    }
+    return out;
+}
+/** Backspace arrives as DEL (0x7f) or BS (0x08) depending on the terminal. */
+function isBackspace(data) {
+    return data === "\x7f" || data === "\b";
+}
+/**
+ * Editor that paints the trigger words and owns the on/off toggle. Reads/writes
+ * `state.active` so the extension's `input` handler can decide whether to force a
+ * workflow at submit time.
+ */
+export class WorkflowEditor extends CustomEditor {
+    modeState;
+    tick = 0;
+    timer;
+    /** Toggled off by Backspace-after-word; re-armed when a fresh trigger appears. */
+    disabled = false;
+    wasTriggered = false;
+    constructor(tui, theme, keybindings, modeState) {
+        super(tui, theme, keybindings);
+        this.modeState = modeState;
+    }
+    /** Highlighted/armed: a trigger is present and the user hasn't toggled it off. */
+    isActive() {
+        return !this.disabled && hasTrigger(this.getText());
+    }
+    handleInput(data) {
+        // First Backspace right after a trigger word disarms (non-destructive).
+        if (isBackspace(data) && this.isActive() && this.cursorAfterTrigger()) {
+            this.disabled = true;
+            this.syncState();
+            this.tui.requestRender();
+            return;
+        }
+        const before = this.getText();
+        super.handleInput(data);
+        const after = this.getText();
+        if (after !== before) {
+            const now = hasTrigger(after);
+            // A freshly typed trigger re-arms a previously disabled box.
+            if (now && !this.wasTriggered)
+                this.disabled = false;
+            this.wasTriggered = now;
+        }
+        this.syncState();
+    }
+    render(width) {
+        const lines = super.render(width);
+        // Keep the shared state current even for non-keystroke changes (history
+        // recall, programmatic setText) so the submit hook reads the right value.
+        this.syncState();
+        this.reconcileAnimation();
+        if (!this.isActive() || lines.length === 0)
+            return lines;
+        // First and last lines are the editor's horizontal borders; only the text
+        // lines in between are colorized.
+        return lines.map((ln, i) => (i === 0 || i === lines.length - 1 ? ln : colorizeWorkflow(ln, this.tick)));
+    }
+    /** Absolute text before the cursor, used to detect "right after the word". */
+    cursorAfterTrigger() {
+        const lines = this.getLines();
+        const { line, col } = this.getCursor();
+        const before = lines.slice(0, line).join("\n") + (line > 0 ? "\n" : "") + (lines[line] ?? "").slice(0, col);
+        return endsWithTrigger(before);
+    }
+    syncState() {
+        this.modeState.active = this.isActive();
+    }
+    reconcileAnimation() {
+        const shouldRun = this.isActive() && this.focused;
+        if (shouldRun && !this.timer) {
+            this.timer = setInterval(() => {
+                this.tick = (this.tick + 1) % (RAINBOW.length * 6);
+                this.tui.requestRender();
+            }, 90);
+            // Don't keep the process alive for the animation.
+            this.timer.unref?.();
+        }
+        else if (!shouldRun && this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+}
+/** The directive appended to a submitted message when workflows mode is armed. */
+export function buildForcedWorkflowPrompt(text) {
+    return [
+        text,
+        "",
+        "[workflows mode] The user armed workflows mode for this message. Handle it by",
+        "running the `workflow` tool: decompose the request and orchestrate subagents",
+        "with a workflow script, rather than answering directly.",
+    ].join("\n");
+}
+/**
+ * Install the workflows-mode editor and the submit-time forcing hook.
+ * Call once with the UI context (e.g. in `session_start`).
+ */
+export function installWorkflowEditor(pi, ui) {
+    const state = { active: false };
+    ui.setEditorComponent((tui, theme, keybindings) => new WorkflowEditor(tui, theme, keybindings, state));
+    // When armed at submit time, rewrite the user's message to force a workflow.
+    pi.on("input", (event) => {
+        if (event.source !== "interactive" || !state.active || !event.text)
+            return { action: "continue" };
+        state.active = false; // consume the arm for this submission
+        return { action: "transform", text: buildForcedWorkflowPrompt(event.text) };
+    });
+    return state;
+}