flashlite 0.0.0-stage → 0.1.1

package/dist/adapters/anthropic.js

@@ -0,0 +1,341 @@
+// Anthropic Messages wire <-> normalized types (pinned 2023-06-01, like the Swift app).
+// Tool results are batched into a single user turn (the flush pattern); signed thinking
+// is retained for continuation but never displayed; refusal text is surfaced as content.
+import { RouterError } from "../client.js";
+import { parseToolArgs } from "./openai.js";
+import { anthropicThinkingBudget, effectiveOutputTokens } from "../effort.js";
+export const ANTHROPIC_DEFAULT_MAX_TOKENS = 8192;
+function thinkingBlock(block) {
+    if (block.type === 'thinking')
+        return {
+            type: 'thinking',
+            thinking: typeof block.thinking === 'string' ? block.thinking : '',
+            signature: typeof block.signature === 'string' ? block.signature : '',
+        };
+    if (block.type === 'redacted_thinking' && typeof block.data === 'string')
+        return { type: 'redacted_thinking', data: block.data };
+    return undefined;
+}
+/** Normalized request -> Messages body. max_tokens is required on this dialect. */
+export function toAnthropicBody(req, options = {}) {
+    const messages = [];
+    let system = req.system;
+    let pendingToolResults = [];
+    const flushToolResults = () => {
+        if (pendingToolResults.length === 0)
+            return;
+        messages.push({
+            role: 'user',
+            content: pendingToolResults.map((r) => ({
+                type: 'tool_result',
+                tool_use_id: r.id,
+                content: r.content,
+                is_error: r.isError,
+            })),
+        });
+        pendingToolResults = [];
+    };
+    for (const m of req.messages) {
+        if (m.role === 'system') {
+            system = system ? `${system}\n${m.content}` : m.content; // stray system messages fold into the top-level prompt
+            continue;
+        }
+        if (m.role === 'assistant') {
+            flushToolResults();
+            const blocks = (m.thinkingBlocks ?? []).map((block) => ({ ...block }));
+            if (m.content)
+                blocks.push({ type: 'text', text: m.content });
+            for (const c of m.toolCalls ?? []) {
+                blocks.push({ type: 'tool_use', id: c.id, name: c.name, input: c.arguments });
+            }
+            if (blocks.length === 0)
+                continue; // content-less turns are dropped (API rejects them)
+            messages.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        if (m.role === 'tool') {
+            // Batch consecutive tool results into one user turn.
+            pendingToolResults.push({ id: m.toolCallId ?? '', content: m.content, isError: m.isError ?? false });
+            continue;
+        }
+        flushToolResults(); // any non-tool message ends the batch (ordering matters)
+        if (m.images?.length) {
+            const content = m.content ? [{ type: 'text', text: m.content }] : [];
+            content.push(...m.images.map((image) => ({
+                type: 'image', source: { type: 'base64', media_type: image.mediaType, data: image.data },
+            })));
+            messages.push({ role: 'user', content });
+        }
+        else
+            messages.push({ role: 'user', content: m.content });
+    }
+    flushToolResults();
+    const budget = anthropicThinkingBudget(req.effort);
+    const maxTokens = effectiveOutputTokens('anthropic', req.maxTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS, req.effort);
+    const body = { model: req.model, max_tokens: maxTokens, messages, stream: req.stream };
+    if (budget)
+        body.thinking = { type: 'enabled', budget_tokens: budget };
+    if (system)
+        body.system = system;
+    if (req.tools && req.tools.length > 0) {
+        body.tools = req.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.parameters,
+        }));
+    }
+    if (options.cache)
+        applyPromptCaching(body, messages);
+    return body;
+}
+/**
+ * Prompt caching: tools + system form one stable prefix, and a second breakpoint on the
+ * newest message lets every tool round reuse everything sent the round before. Cached
+ * input is billed at a fraction of the normal rate, which is the big saving for agent loops.
+ */
+function applyPromptCaching(body, messages) {
+    const marker = { type: 'ephemeral' };
+    if (typeof body.system === 'string' && body.system) {
+        body.system = [{ type: 'text', text: body.system, cache_control: marker }];
+    }
+    const last = messages[messages.length - 1];
+    if (!last)
+        return;
+    if (typeof last.content === 'string') {
+        if (last.content)
+            last.content = [{ type: 'text', text: last.content, cache_control: marker }];
+    }
+    else if (Array.isArray(last.content) && last.content.length) {
+        const blocks = last.content;
+        blocks[blocks.length - 1] = { ...blocks[blocks.length - 1], cache_control: marker };
+    }
+}
+/** stop_reason mapping for the Messages API (Swift parity). */
+export function mapAnthropicStopReason(reason) {
+    switch (reason) {
+        case 'end_turn':
+        case 'stop_sequence':
+            return 'stop';
+        case 'tool_use':
+            return 'tool_calls';
+        case 'max_tokens':
+            return 'length';
+        case 'refusal':
+            return 'refusal';
+        default:
+            return 'unknown';
+    }
+}
+/**
+ * Streaming assembly for the Messages API: message_start → input tokens;
+ * content_block_start(tool_use) → tool_call_start; text_delta → text;
+ * input_json_delta → tool_call_args (accumulated, parsed only at the end);
+ * thinking/signature deltas retained silently; message_delta → stop_reason/output tokens;
+ * message_stop → single stop event. Refusals surface as text.
+ */
+export class AnthropicStreamParser {
+    textParts = [];
+    blocks = new Map();
+    toolSeq = 0; // tool_use blocks get sequential indexes, gaps or not
+    inputTokens;
+    outputTokens;
+    cachedInputTokens;
+    stopReason;
+    done = false;
+    push(payload) {
+        if (this.done)
+            return []; // message_stop is final — later frames are ignored
+        const data = JSON.parse(payload);
+        const type = data.type;
+        const events = [];
+        if (type === 'error') {
+            const err = data.error;
+            const errObj = typeof err === 'object' && err !== null ? err : undefined;
+            throw new RouterError(typeof errObj?.message === 'string' ? errObj.message : 'The router returned an error event.');
+        }
+        if (type === 'ping')
+            return events;
+        if (type === 'message_start') {
+            const msg = data.message;
+            if (typeof msg === 'object' && msg !== null) {
+                const usage = msg.usage;
+                if (typeof usage === 'object' && usage !== null) {
+                    const u = usage;
+                    this.inputTokens = typeof u.input_tokens === 'number' ? u.input_tokens : this.inputTokens;
+                    this.cachedInputTokens = typeof u.cache_read_input_tokens === 'number' ? u.cache_read_input_tokens : this.cachedInputTokens;
+                }
+            }
+            return events;
+        }
+        if (type === 'content_block_start') {
+            const block = data.content_block;
+            const index = typeof data.index === 'number' ? data.index : this.blocks.size;
+            if (typeof block === 'object' && block !== null && block.type === 'tool_use') {
+                const b = block;
+                const seq = this.toolSeq++;
+                this.blocks.set(index, {
+                    text: '',
+                    tool: { id: typeof b.id === 'string' ? b.id : '', name: typeof b.name === 'string' ? b.name : '', partialJson: '' },
+                });
+                events.push({ kind: 'tool_call_start', index: seq, id: this.blocks.get(index).tool.id, name: this.blocks.get(index).tool.name });
+            }
+            else {
+                this.blocks.set(index, { text: '', thinking: typeof block === 'object' && block !== null ? thinkingBlock(block) : undefined });
+            }
+            return events;
+        }
+        if (type === 'content_block_delta') {
+            const index = typeof data.index === 'number' ? data.index : 0;
+            const delta = data.delta;
+            if (typeof delta !== 'object' || delta === null)
+                return events;
+            const d = delta;
+            const state = this.blocks.get(index) ?? { text: '' };
+            this.blocks.set(index, state);
+            if (d.type === 'text_delta' && typeof d.text === 'string') {
+                this.textParts.push(d.text);
+                events.push({ kind: 'text', text: d.text });
+            }
+            else if (d.type === 'refusal_delta' && typeof d.refusal === 'string') {
+                this.textParts.push(d.refusal); // surfaced as content, not as a tool result
+                events.push({ kind: 'text', text: d.refusal });
+            }
+            else if (d.type === 'input_json_delta' && typeof d.partial_json === 'string') {
+                if (!state.tool)
+                    state.tool = { id: '', name: '', partialJson: '' };
+                state.tool.partialJson += d.partial_json;
+                events.push({ kind: 'tool_call_args', index: this.seqFor(index), delta: d.partial_json });
+            }
+            else if (state.thinking?.type === 'thinking') {
+                if (d.type === 'thinking_delta' && typeof d.thinking === 'string')
+                    state.thinking.thinking += d.thinking;
+                else if (d.type === 'signature_delta' && typeof d.signature === 'string')
+                    state.thinking.signature += d.signature;
+            }
+            // Signed thinking is retained for tool continuations, never emitted to the UI.
+            return events;
+        }
+        if (type === 'content_block_stop') {
+            return events;
+        }
+        if (type === 'message_delta') {
+            const delta = data.delta;
+            if (typeof delta === 'object' && delta !== null && typeof delta.stop_reason === 'string') {
+                this.stopReason = mapAnthropicStopReason(delta.stop_reason);
+            }
+            const usage = data.usage;
+            if (typeof usage === 'object' && usage !== null && typeof usage.output_tokens === 'number') {
+                this.outputTokens = usage.output_tokens;
+            }
+            return events;
+        }
+        if (type === 'message_stop') {
+            this.done = true;
+            const usage = this.inputTokens !== undefined && this.outputTokens !== undefined
+                ? {
+                    inputTokens: this.inputTokens,
+                    outputTokens: this.outputTokens,
+                    ...(this.cachedInputTokens !== undefined ? { cachedInputTokens: this.cachedInputTokens } : {}),
+                }
+                : undefined;
+            events.push({ kind: 'stop', stopReason: this.stopReason ?? 'unknown', usage });
+            return events;
+        }
+        return events; // unknown event types are ignored, never fatal
+    }
+    seqFor(index) {
+        // Map a content-block index back to the sequential tool index it was assigned.
+        const ordered = [...this.blocks.entries()];
+        let seq = 0;
+        for (const [i, s] of ordered) {
+            if (i === index)
+                return seq;
+            if (s.tool)
+                seq++;
+        }
+        return 0;
+    }
+    assistantMessage() {
+        const toolCalls = [];
+        for (const s of this.blocks.values()) {
+            if (!s.tool)
+                continue;
+            const { arguments: parsed, invalid } = parseToolArgs(s.tool.partialJson);
+            toolCalls.push({
+                id: s.tool.id,
+                name: s.tool.name,
+                arguments: parsed,
+                argumentsJson: s.tool.partialJson,
+                argumentsInvalid: invalid,
+            });
+        }
+        const message = { role: 'assistant', content: this.textParts.join('') };
+        if (toolCalls.length > 0)
+            message.toolCalls = toolCalls;
+        const thinkingBlocks = [...this.blocks.values()].flatMap((state) => state.thinking ? [{ ...state.thinking }] : []);
+        if (thinkingBlocks.length)
+            message.thinkingBlocks = thinkingBlocks;
+        return message;
+    }
+}
+/** Non-streaming Messages response -> normalized turn. */
+export function parseAnthropicCompleteBody(json) {
+    if (typeof json !== 'object' || json === null) {
+        throw new RouterError('Unexpected response from the router (not an object).');
+    }
+    const body = json;
+    if (body.type === 'error') {
+        const err = body.error;
+        const errObj = typeof err === 'object' && err !== null ? err : undefined;
+        throw new RouterError(typeof errObj?.message === 'string' ? errObj.message : 'The router returned an error.');
+    }
+    if (!Array.isArray(body.content)) {
+        throw new RouterError('Unexpected response from the router (no content array).');
+    }
+    const textParts = [];
+    const toolCalls = [];
+    const thinkingBlocks = [];
+    for (const block of body.content) {
+        if (typeof block !== 'object' || block === null)
+            continue;
+        const thinking = thinkingBlock(block);
+        if (thinking)
+            thinkingBlocks.push(thinking);
+        if (block.type === 'text' && typeof block.text === 'string')
+            textParts.push(block.text);
+        if (block.type === 'refusal' && typeof block.refusal === 'string')
+            textParts.push(block.refusal);
+        if (block.type === 'tool_use') {
+            const input = block.input;
+            const rawArgs = typeof input === 'object' && input !== null ? JSON.stringify(input) : '';
+            const { arguments: parsed, invalid } = parseToolArgs(rawArgs);
+            toolCalls.push({
+                id: typeof block.id === 'string' ? block.id : '',
+                name: typeof block.name === 'string' ? block.name : '',
+                arguments: parsed,
+                argumentsJson: rawArgs,
+                argumentsInvalid: invalid,
+            });
+        }
+    }
+    const message = { role: 'assistant', content: textParts.join('') };
+    if (toolCalls.length > 0)
+        message.toolCalls = toolCalls;
+    if (thinkingBlocks.length)
+        message.thinkingBlocks = thinkingBlocks;
+    const stopReason = typeof body.stop_reason === 'string' ? mapAnthropicStopReason(body.stop_reason) : 'unknown';
+    const usageWire = body.usage;
+    let usage;
+    if (typeof usageWire === 'object' && usageWire !== null) {
+        const u = usageWire;
+        if (typeof u.input_tokens === 'number' && typeof u.output_tokens === 'number') {
+            const cached = typeof u.cache_read_input_tokens === 'number' ? u.cache_read_input_tokens : undefined;
+            usage = {
+                inputTokens: u.input_tokens,
+                outputTokens: u.output_tokens,
+                ...(cached !== undefined ? { cachedInputTokens: cached } : {}),
+            };
+        }
+    }
+    return { message, stopReason, usage };
+}

package/dist/adapters/openai.js

@@ -0,0 +1,241 @@
+// OpenAI Chat Completions wire <-> normalized types.
+// Arguments travel as JSON strings; tool-call deltas arrive chunked by index and are
+// merged here, never parsed mid-stream.
+import { RouterError } from "../client.js";
+import { deepSeekWireEffort, isDeepSeek } from "../effort.js";
+/** Normalized request -> Chat Completions body. */
+export function toWireBody(req) {
+    const messages = [];
+    if (req.system)
+        messages.push({ role: 'system', content: req.system });
+    for (const m of req.messages) {
+        if (m.role === 'assistant') {
+            const wire = { role: 'assistant', content: m.content };
+            if (m.toolCalls && m.toolCalls.length > 0) {
+                wire.tool_calls = m.toolCalls.map((c) => ({
+                    id: c.id,
+                    type: 'function',
+                    function: { name: c.name, arguments: c.argumentsJson },
+                }));
+            }
+            // A tool_calls-only turn must not carry an empty content string.
+            if (!m.content && wire.tool_calls)
+                delete wire.content;
+            // Multi-turn contract (router docs): prior-turn CoT is concatenated only while the
+            // request carries tools; a tool-less request must omit it.
+            if (m.reasoningContent && req.tools && req.tools.length > 0)
+                wire.reasoning_content = m.reasoningContent;
+            messages.push(wire);
+        }
+        else if (m.role === 'tool') {
+            messages.push({ role: 'tool', tool_call_id: m.toolCallId ?? '', content: m.content });
+        }
+        else if (m.role === 'user' && m.images?.length) {
+            const content = m.content ? [{ type: 'text', text: m.content }] : [];
+            content.push(...m.images.map((image) => ({
+                type: 'image_url', image_url: { url: `data:${image.mediaType};base64,${image.data}` },
+            })));
+            messages.push({ role: 'user', content });
+        }
+        else {
+            messages.push({ role: m.role, content: m.content });
+        }
+    }
+    const body = { model: req.model, messages, stream: req.stream };
+    // Ask OpenAI-compatible providers to emit token usage (including cache hits) on the
+    // final stream chunk; without this the client has no usage to report at all.
+    if (req.stream)
+        body.stream_options = { include_usage: true };
+    if (req.tools && req.tools.length > 0) {
+        body.tools = req.tools.map((t) => ({
+            type: 'function',
+            function: { name: t.name, description: t.description, parameters: t.parameters },
+        }));
+    }
+    if (req.maxTokens)
+        body.max_tokens = req.maxTokens;
+    if (req.effort && req.effort !== 'auto') {
+        // DeepSeek only accepts a subset of reasoning levels; coerce CLI levels onto the
+        // provider's real ones. Other models keep sending the CLI level verbatim.
+        body.reasoning_effort = isDeepSeek(req.model) ? deepSeekWireEffort(req.model, req.effort) : req.effort;
+    }
+    return body;
+}
+/** Lenient tool-arguments parse: {} plus a flag on malformed JSON, never a throw. */
+export function parseToolArgs(raw) {
+    try {
+        const value = JSON.parse(raw || '{}');
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            return { arguments: value, invalid: false };
+        }
+        return { arguments: {}, invalid: true };
+    }
+    catch {
+        return { arguments: {}, invalid: true };
+    }
+}
+function parseWireToolCalls(wire) {
+    if (!Array.isArray(wire))
+        return [];
+    const result = [];
+    for (const entry of wire) {
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        const c = entry;
+        const fn = c.function;
+        const name = typeof fn === 'object' && fn !== null ? fn.name : undefined;
+        if (typeof c.id !== 'string' || typeof name !== 'string')
+            continue;
+        const rawArgs = typeof fn === 'object' && fn !== null ? fn.arguments ?? '' : '';
+        const { arguments: parsed, invalid } = parseToolArgs(rawArgs);
+        result.push({ id: c.id, name, arguments: parsed, argumentsJson: rawArgs, argumentsInvalid: invalid });
+    }
+    return result;
+}
+export function mapFinishReason(finishReason) {
+    switch (finishReason) {
+        case 'stop':
+            return 'stop';
+        case 'tool_calls':
+            return 'tool_calls';
+        case 'length':
+            return 'length';
+        case 'content_filter':
+            return 'refusal';
+        default:
+            return 'unknown';
+    }
+}
+function parseUsage(wire) {
+    if (typeof wire !== 'object' || wire === null)
+        return undefined;
+    const u = wire;
+    if (typeof u.prompt_tokens !== 'number' || typeof u.completion_tokens !== 'number')
+        return undefined;
+    const details = (u.prompt_tokens_details ?? {});
+    // DeepSeek reports prompt_cache_hit_tokens; OpenAI-compatible APIs report
+    // prompt_tokens_details.cached_tokens. Either way it is a subset of prompt_tokens.
+    const cached = typeof details.cached_tokens === 'number'
+        ? details.cached_tokens
+        : typeof u.prompt_cache_hit_tokens === 'number'
+            ? u.prompt_cache_hit_tokens
+            : undefined;
+    return {
+        inputTokens: u.prompt_tokens,
+        outputTokens: u.completion_tokens,
+        ...(cached !== undefined ? { cachedInputTokens: cached } : {}),
+    };
+}
+/** Non-streaming Chat Completions response -> AssistantTurn. */
+export function parseCompleteBody(json) {
+    const root = json;
+    const choice = root.choices?.[0];
+    if (!choice || typeof choice !== 'object') {
+        throw new RouterError('The router returned an invalid completion response.');
+    }
+    const msg = (choice.message ?? {});
+    const content = typeof msg.content === 'string' ? msg.content : '';
+    const toolCalls = parseWireToolCalls(msg.tool_calls);
+    const message = { role: 'assistant', content };
+    if (toolCalls.length > 0)
+        message.toolCalls = toolCalls;
+    if (typeof msg.reasoning_content === 'string' && msg.reasoning_content)
+        message.reasoningContent = msg.reasoning_content;
+    return {
+        message,
+        stopReason: mapFinishReason(choice.finish_reason),
+        usage: parseUsage(root.usage),
+    };
+}
+/**
+ * Streaming state machine. Feed one SSE `data:` payload per push(); get StreamEvents.
+ * Emits a single 'stop' event once finish_reason appears (verified live: the final
+ * chunk carries finish_reason + usage).
+ */
+export class OpenAiStreamParser {
+    text = '';
+    reasoning = '';
+    toolCalls = [];
+    stopped = false;
+    push(payload) {
+        if (this.stopped)
+            return [];
+        let json;
+        try {
+            json = JSON.parse(payload);
+        }
+        catch {
+            throw new RouterError('The router returned an invalid streaming response.');
+        }
+        const root = json;
+        if (root.error) {
+            const err = root.error;
+            const message = typeof err.message === 'string' ? err.message : 'The router could not complete the stream.';
+            throw new RouterError(message);
+        }
+        const events = [];
+        const choice = root.choices?.[0];
+        const delta = (choice?.delta ?? {});
+        if (typeof delta.content === 'string' && delta.content) {
+            this.text += delta.content;
+            events.push({ kind: 'text', text: delta.content });
+        }
+        if (typeof delta.reasoning_content === 'string' && delta.reasoning_content) {
+            this.reasoning += delta.reasoning_content;
+            events.push({ kind: 'reasoning', text: delta.reasoning_content });
+        }
+        if (Array.isArray(delta.tool_calls)) {
+            for (const call of delta.tool_calls) {
+                if (typeof call !== 'object' || call === null)
+                    continue;
+                const index = typeof call.index === 'number' ? call.index : 0;
+                let entry = this.toolCalls.find((t) => t.index === index);
+                if (!entry) {
+                    entry = { index, id: '', name: '', args: '', started: false };
+                    this.toolCalls.push(entry);
+                }
+                if (typeof call.id === 'string' && call.id)
+                    entry.id = call.id;
+                const fn = call.function;
+                let argDelta = '';
+                if (typeof fn === 'object' && fn !== null) {
+                    if (typeof fn.name === 'string' && fn.name)
+                        entry.name = fn.name;
+                    if (typeof fn.arguments === 'string') {
+                        argDelta = fn.arguments;
+                        entry.args += argDelta;
+                    }
+                }
+                if (!entry.started) {
+                    entry.started = true;
+                    events.push({ kind: 'tool_call_start', index, id: entry.id, name: entry.name });
+                }
+                if (argDelta) {
+                    events.push({ kind: 'tool_call_args', index, delta: argDelta });
+                }
+            }
+        }
+        if (typeof choice?.finish_reason === 'string' && choice.finish_reason) {
+            const usage = parseUsage(root.usage);
+            this.stopped = true;
+            events.push({ kind: 'stop', stopReason: mapFinishReason(choice.finish_reason), usage });
+        }
+        return events;
+    }
+    /** The assembled assistant message for this turn. */
+    assistantMessage() {
+        const message = { role: 'assistant', content: this.text };
+        if (this.toolCalls.length > 0) {
+            message.toolCalls = this.toolCalls.map((t) => {
+                const { arguments: parsed, invalid } = parseToolArgs(t.args);
+                return { id: t.id, name: t.name, arguments: parsed, argumentsJson: t.args, argumentsInvalid: invalid };
+            });
+        }
+        if (this.reasoning)
+            message.reasoningContent = this.reasoning;
+        return message;
+    }
+    reasoningSoFar() {
+        return this.reasoning;
+    }
+}

package/dist/approval.js

@@ -0,0 +1,28 @@
+// Permission modes are session-local; the legacy auto_approve setting is file-only.
+export const APPROVAL_MODES = ['ask', 'files', 'auto', 'absolute'];
+export const APPROVAL_DESCRIPTIONS = {
+    ask: 'Ask before file changes and terminal commands',
+    files: 'Allow project file changes; ask before terminal commands',
+    auto: 'Allow files and commands; ask before network, installs, sudo, outside paths and destructive operations',
+    absolute: 'Whole drive and every command run without prompts; only recognizable catastrophic deletion or disk commands ask',
+};
+export const APPROVAL_LABELS = {
+    ask: 'ask before writes',
+    files: 'files allowed · commands ask',
+    auto: 'guarded auto',
+    absolute: 'unguarded auto',
+};
+/** Short names for the mode picker; the internal id `absolute` is never shown to the user. */
+export const APPROVAL_NAMES = {
+    ask: 'ask',
+    files: 'files',
+    auto: 'auto',
+    absolute: 'unguarded',
+};
+/** The internal id stays `absolute`; users type `unguarded`/`unguarded auto` or the legacy `absolute`. */
+export function parseApprovalMode(value) {
+    const key = value.trim().toLowerCase();
+    if (key === 'unguarded' || key === 'unguarded auto')
+        return 'absolute';
+    return APPROVAL_MODES.find((mode) => mode === key);
+}

package/dist/boostworkflow.js

@@ -0,0 +1,15 @@
+/** Conservative gate: Boost never turns casual chat or a tiny edit into extra model calls. */
+export function boostRoles(task) {
+    const text = task.trim();
+    if (text.length < 60 || /^(?:hi|hello|hey|thanks|what is|explain|summarize)\b/i.test(text))
+        return [];
+    const substantial = /\b(?:implement|build|refactor|redesign|investigate|debug|fix|review|improve|migrate|create|audit|overhaul)\b/i.test(text);
+    if (!substantial)
+        return [];
+    const ui = /\b(?:ui|ux|interface|layout|design|visual|accessibility|theme|tui)\b/i.test(text);
+    const research = /\b(?:research|documentation|docs|latest|web|online|compare providers)\b/i.test(text);
+    if (research)
+        return ['researcher', 'code'];
+    return ui ? ['ui-ux', 'code'] : ['code', 'reviewer'];
+}
+export const BOOST_WORKFLOW_GUIDANCE = `Boost workflow (host-selected for a substantial task): independent read-only helpers are inspecting relevant files, locating code and researching prerequisites while you work. Their completed findings arrive at safe model-round boundaries. Continue implementation now; use useful findings to avoid duplicate investigation, but verify before relying on them. You own edits, commands, approvals and focused validation. Keep user-selected model and effort, report what passed or remains unverified, and do not spawn redundant helpers.`;