tinybeeai 0.0.0-stage → 0.16.1

package/dist/agent/llm.js

@@ -0,0 +1,1464 @@
+// LLM wrapper. AnthropicLlm talks to Claude; MockLlm derives deterministic verdicts from the
+// inputs so the product demos offline with realistic output.
+import Anthropic from '@anthropic-ai/sdk';
+import { COMPOSE_VIEW_TOOL, modelFacing } from './chat-views.js';
+import { asksForComposedView, mockComposedReply } from './mock-views.js';
+import { callChatTool, chatToolsFor, closeViewStreams, designRequestHeld, plannedFirstTool, reviewHasConditions, reviewIntent, reviewRequestHeld, viewStreamOpener, } from './chat.js';
+import { ClaudeCliLlm } from './llm-cli.js';
+import { liveEnv, log, onSettingsChange } from '../config.js';
+import { update } from '../db.js';
+import { countedCall } from '../model-usage.js';
+import { currentRunId } from '../queue.js';
+import { CodexCliLlm } from './llm-codex.js';
+import { OPENAI_COMPAT_SETTING_KEYS, OpenAiCompatLlm } from './llm-openai.js';
+import { classifyThrown, ModelUnavailableError, rethrowIfUnavailable } from './model-errors.js';
+import { GuardedLlm, startRecheckTimer } from './model-guard.js';
+import { FAMILY_LABEL, FAMILY_OF_METHOD, dueForRecheck, getUnavailability, markUnavailable } from './model-availability.js';
+import { addStep } from './runs.js';
+import { getReport } from '../reports/index.js';
+import { REVIEW_SYSTEM, SCORE_SYSTEM, renderActionForReview, renderAnalyzeInput, renderTicket, renderWatchForChat, systemFor, chatSystemFor, } from './prompts.js';
+import { presetHintsForWatch } from '../connections/presets.js';
+import { redact } from './redact.js';
+import { reportReasoning } from './reasoning.js';
+import { scrubVerdict } from './team-notes.js';
+export const ANALYSIS_MODEL = 'claude-sonnet-5-5';
+export const FAST_MODEL = 'claude-haiku-4-5-20251001';
+/** Main model for the Anthropic API backend: LOCALDOST_MODEL (env or saved in Setup), else ANALYSIS_MODEL. */
+export function mainModel() {
+    return liveEnv.LOCALDOST_MODEL?.trim() || ANALYSIS_MODEL;
+}
+/** Fast model for scoring and auto-review: LOCALDOST_FAST_MODEL, else FAST_MODEL. */
+export function fastModel() {
+    return liveEnv.LOCALDOST_FAST_MODEL?.trim() || FAST_MODEL;
+}
+/** Settings that pick or configure the model backend. A change drops the cached instance. */
+export const MODEL_SETTING_KEYS = [
+    'LOCALDOST_LLM',
+    'ANTHROPIC_API_KEY',
+    'CLAUDE_CODE_OAUTH_TOKEN',
+    'LOCALDOST_MODEL',
+    'LOCALDOST_FAST_MODEL',
+    'LOCALDOST_CLAUDE_MODEL',
+    'LOCALDOST_CLAUDE_FAST_MODEL',
+    'LOCALDOST_CLAUDE_BIN',
+    'LOCALDOST_CODEX_MODEL',
+    'LOCALDOST_CODEX_BIN',
+    ...OPENAI_COMPAT_SETTING_KEYS,
+];
+let instance;
+/** Backends other than the chosen one, built when a call needs to fall back (KAT-102). */
+const spare = new Map();
+/** True while a test pinned the instance with setLlm(); settings changes then leave it alone. */
+let pinned = false;
+onSettingsChange((keys) => {
+    if (keys.some((k) => MODEL_SETTING_KEYS.includes(k) || k.startsWith('LOCALDOST_CODEX_')))
+        spare.clear();
+    if (!pinned && keys.some((k) => MODEL_SETTING_KEYS.includes(k)))
+        instance = undefined;
+});
+/** Backend name for the boot log. */
+export function llmBackend() {
+    const l = rawLlm();
+    if (l instanceof ClaudeCliLlm)
+        return 'claude-cli';
+    if (l instanceof CodexCliLlm)
+        return 'codex-cli';
+    if (l instanceof AnthropicLlm)
+        return 'anthropic';
+    if (l instanceof OpenAiCompatLlm)
+        return 'openai-compat';
+    return 'mock';
+}
+/**
+ * The backend the settings pick, without the model guard. LOCALDOST_LLM: claude-cli (KAT-30), codex-cli (KAT-68),
+ * anthropic, openai-compat (the preset TINYBEE_MODEL_BACKEND names: OpenAI, Gemini, Ollama, LM Studio or a custom
+ * endpoint, src/agent/llm-openai.ts), or mock. Unset: Anthropic when ANTHROPIC_API_KEY is set, else the mock.
+ * Everything here runs on this laptop with the person's own access; a paired Bee never sends host work to Hive's AI.
+ */
+export function rawLlm() {
+    if (!instance) {
+        const pick = (liveEnv.LOCALDOST_LLM ?? '').trim().toLowerCase();
+        if (pick === 'claude-cli')
+            instance = new ClaudeCliLlm();
+        else if (pick === 'codex-cli')
+            instance = new CodexCliLlm();
+        else if (pick === 'mock')
+            instance = new MockLlm();
+        else if (pick === 'openai-compat')
+            instance = OpenAiCompatLlm.fromSettings() ?? new MockLlm();
+        else if (pick === 'anthropic' || liveEnv.ANTHROPIC_API_KEY)
+            instance = new AnthropicLlm();
+        else
+            instance = new MockLlm();
+    }
+    return instance;
+}
+export function familyOfLlm(l) {
+    if (l instanceof ClaudeCliLlm)
+        return 'claude';
+    if (l instanceof CodexCliLlm)
+        return 'codex';
+    if (l instanceof AnthropicLlm)
+        return 'anthropic';
+    return undefined;
+}
+function spareLlm(family) {
+    let l = spare.get(family);
+    if (!l) {
+        l = family === 'claude' ? new ClaudeCliLlm() : family === 'codex' ? new CodexCliLlm() : new AnthropicLlm();
+        spare.set(family, l);
+    }
+    return l;
+}
+/** Where the guard finds its backends: the chosen one, then the signed-in ones of the model switcher list (KAT-83). */
+const llmSource = {
+    preferred: () => familyOfLlm(rawLlm()),
+    primary: () => rawLlm(),
+    async others(pref) {
+        const { workingFamilies } = await import('../connect/model-choices.js');
+        return (await workingFamilies()).filter((f) => f !== pref).map((family) => ({ family, backend: spareLlm(family) }));
+    },
+};
+/** Test hook: the backend a call falls back to for this family. No backend removes it. */
+export function setSpareLlm(family, llm) {
+    if (llm)
+        spare.set(family, llm);
+    else
+        spare.delete(family);
+}
+let guarded;
+/**
+ * The model every caller uses. It is the chosen backend behind the model guard (model-guard.ts): a quota,
+ * spend cap, rate limit or sign-in error moves the call to the next working model, or throws
+ * ModelUnavailableError when none works. Use rawLlm() to look at the backend itself.
+ */
+export function getLlm() {
+    return (guarded ??= new GuardedLlm(llmSource));
+}
+// ---------- model per stage (KAT-162, docs/STAGES.md section 5.4) ----------
+/** The ids a dot may pick per stage: the switcher list of src/connect/model-choices.ts. */
+export const STAGE_MODEL_IDS = Object.keys(FAMILY_OF_METHOD);
+/** The model a run used, as `backend/model`. The mock names itself. */
+export function modelLabel(family) {
+    if (family === 'claude')
+        return `claude-cli/${liveEnv.LOCALDOST_CLAUDE_MODEL?.trim() || liveEnv.LOCALDOST_MODEL?.trim() || 'sonnet'}`;
+    if (family === 'codex')
+        return `codex-cli/${liveEnv.LOCALDOST_CODEX_MODEL?.trim() || 'default'}`;
+    if (family === 'anthropic')
+        return `anthropic/${mainModel()}`;
+    return 'mock';
+}
+/** The label of the model the settings pick for stages with no model of their own. */
+export function defaultModelLabel() {
+    return modelLabel(familyOfLlm(rawLlm()));
+}
+/** Writes the model onto the run the calling job is working on. A missing run or store error never fails the call. */
+export function recordRunModel(label) {
+    const id = currentRunId();
+    if (!id)
+        return;
+    try {
+        update('runs', id, { model: label });
+    }
+    catch {
+        /* the run row is gone */
+    }
+}
+const noted = new Set();
+function noteStageFallback(stage, who, why) {
+    const detail = `The ${stage} stage is set to ${who}, which ${why}. Using the dot's default model instead.`;
+    log.warn(`model: ${detail}`);
+    const id = currentRunId();
+    if (!id)
+        return;
+    const key = `${id}:${stage}:${why}`;
+    if (noted.has(key))
+        return;
+    noted.add(key);
+    if (noted.size > 500)
+        noted.delete(noted.values().next().value);
+    try {
+        addStep(id, 'Stage model unavailable', detail, 'warn');
+    }
+    catch {
+        /* the run row is gone */
+    }
+}
+/**
+ * The backend a stage asks for, or undefined when the dot's default model runs the stage: no entry for the
+ * stage, the default is the mock (demo mode keeps the mock for every stage), the stage names the default's own
+ * backend, or the named backend is not signed in or is waiting after a quota error. The last cases leave a log
+ * line and a run step. Never throws.
+ */
+export async function pickStageModel(watch, stage) {
+    const id = stage ? watch.stageModels?.[stage] : undefined;
+    if (!stage || !id)
+        return undefined;
+    const family = FAMILY_OF_METHOD[id];
+    if (!family) {
+        noteStageFallback(stage, `the model "${String(id)}"`, 'is not on the model list');
+        return undefined;
+    }
+    const def = familyOfLlm(rawLlm());
+    if (!def || def === family)
+        return undefined;
+    const who = FAMILY_LABEL[family];
+    try {
+        const { workingFamilies } = await import('../connect/model-choices.js');
+        if (!(await workingFamilies()).includes(family)) {
+            noteStageFallback(stage, who, 'is not signed in or not available');
+            return undefined;
+        }
+    }
+    catch (err) {
+        noteStageFallback(stage, who, `could not be checked (${err instanceof Error ? err.message : String(err)})`);
+        return undefined;
+    }
+    const e = getUnavailability(family);
+    if (e && !dueForRecheck(family)) {
+        noteStageFallback(stage, who, `is unavailable (${e.reason})`);
+        return undefined;
+    }
+    return { family, id };
+}
+/**
+ * The backend that answers for a dot: the default model of the workspace. A stage that names another model falls back to it when that
+ * model is signed out or unavailable (pickStageModel), so only the default model's sign-in can stop a dot.
+ */
+export function defaultFamily() {
+    return familyOfLlm(rawLlm());
+}
+/** The backend instance of a family: the chosen one when it matches, else the spare. */
+export function llmOfFamily(family) {
+    const raw = rawLlm();
+    return familyOfLlm(raw) === family ? raw : spareLlm(family);
+}
+/** Records a stage backend that failed with a quota, spend cap, rate limit or sign-in error, and says so on the run. */
+export function stageModelFailed(stage, family, err) {
+    markUnavailable(family, err);
+    noteStageFallback(stage, FAMILY_LABEL[family], `failed (${err.reason})`);
+}
+/** The model of one stage. Every call tries the stage's model, then falls back to getLlm(). Chat and auto-review use the default. */
+class StageLlm {
+    watch;
+    stage;
+    constructor(watch, stage) {
+        this.watch = watch;
+        this.stage = stage;
+    }
+    /** The backend a free-text check looks at: the stage's own when it has one, else the chosen one. */
+    unwrap() {
+        const id = this.watch.stageModels?.[this.stage];
+        const family = id ? FAMILY_OF_METHOD[id] : undefined;
+        const def = familyOfLlm(rawLlm());
+        return family && def && family !== def ? llmOfFamily(family) : rawLlm();
+    }
+    async run(call) {
+        const pick = await pickStageModel(this.watch, this.stage);
+        if (pick) {
+            try {
+                const out = await countedCall(pick.family, () => call(llmOfFamily(pick.family)));
+                recordRunModel(modelLabel(pick.family));
+                return out;
+            }
+            catch (err) {
+                if (!(err instanceof ModelUnavailableError))
+                    throw err;
+                stageModelFailed(this.stage, pick.family, err);
+            }
+        }
+        const out = await call(getLlm());
+        recordRunModel(defaultModelLabel());
+        return out;
+    }
+    async analyze(req) {
+        // A stage model skips the GuardedLlm, so the team notes guard runs here too (KAT-383).
+        return scrubVerdict(req, await this.run((l) => l.analyze(req)));
+    }
+    score(ticket) {
+        return this.run((l) => l.score(ticket));
+    }
+    write(req) {
+        return this.run((l) => (l.write ? l.write(req) : Promise.reject(new Error('this model backend writes no free text'))));
+    }
+    /** The safety review keeps the default model. */
+    review(action, watch) {
+        return getLlm().review(action, watch);
+    }
+    /** Chat keeps the default model. */
+    chat(req, onDelta, onTool) {
+        return getLlm().chat(req, onDelta, onTool);
+    }
+}
+/**
+ * The model for one stage of a dot. With `watch.stageModels[stage]` set and that model signed in and ready, calls
+ * go to it. Otherwise they go to getLlm(), the dot's default model, with a log line and a run step when a set model
+ * could not be used. It never fails the job over the stage model. A call with no stage is getLlm(): chat, the
+ * safety review, and anything else that belongs to no stage.
+ */
+export function getLlmFor(watch, stage) {
+    return stage ? new StageLlm(watch, stage) : getLlm();
+}
+/** True when the backend behind `llm` writes free text. For getLlm() that is the chosen backend; the mock writes none. */
+export function canWriteText(llm = getLlm()) {
+    const target = llm instanceof GuardedLlm || llm instanceof StageLlm ? llm.unwrap() : llm;
+    return typeof target.write === 'function';
+}
+/**
+ * One free-text answer from the main model (KAT-282): the model's raw text, or null when the
+ * backend writes no free text (the mock), the reply is empty, or the call failed. Through
+ * getLlm() a quota, spend cap, rate limit or expired sign-in falls back to the next working model
+ * like every other call, and ModelUnavailableError is thrown when none works.
+ */
+export async function writeText(req, opts = {}) {
+    const llm = opts.llm ?? getLlm();
+    const fail = (reason) => {
+        opts.onFailure?.(reason);
+        return null;
+    };
+    if (!canWriteText(llm) || !llm.write)
+        return fail('this model backend writes no free text');
+    try {
+        const text = await llm.write(req);
+        return typeof text === 'string' && text.trim() ? text : fail('the model returned no text');
+    }
+    catch (err) {
+        rethrowIfUnavailable(err);
+        const reason = redact(err instanceof Error ? err.message : String(err)).slice(0, 300);
+        console.warn(`[llm] free-text call failed: ${reason}`);
+        return fail(reason);
+    }
+}
+const PROBE_TICKET = { key: 'PROBE-1', id: '0', tracker: 'jira', title: 'Check that the model answers', description: 'Reply with a score.' };
+/** Boot hook: tests the chosen model when its wait is over and no call came. Returns the stop function. */
+export function startModelRecheck() {
+    return startRecheckTimer(llmSource, (l) => l.score(PROBE_TICKET));
+}
+/** Test hook: swap the implementation. */
+export function setLlm(llm) {
+    instance = llm;
+    pinned = llm !== undefined;
+}
+// ---------- shared schema and normalization ----------
+const OUTCOMES = ['pass', 'product_failure', 'test_failure', 'environment_failure', 'flaky', 'needs_attention', 'info'];
+const LEVELS = ['low', 'medium', 'high'];
+const VERDICT_TOOL = {
+    name: 'report_verdict',
+    description: 'Report the QA verdict for this task. Call exactly once.',
+    strict: true,
+    input_schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            outcome: { type: 'string', enum: OUTCOMES },
+            headline: { type: 'string', description: 'One sentence, under 120 characters, readable on a lock screen.' },
+            summary: { type: 'string', description: 'Markdown body for the PR or ticket comment.' },
+            risk: { type: 'string', enum: [...LEVELS] },
+            findings: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        title: { type: 'string' },
+                        detail: { type: 'string' },
+                        severity: { type: 'string', enum: [...LEVELS] },
+                        file: { type: 'string' },
+                        line: { type: 'integer' },
+                    },
+                    required: ['title', 'detail', 'severity'],
+                },
+            },
+            openQuestions: { type: 'array', items: { type: 'string' } },
+            answeredQuestions: {
+                type: 'array',
+                description: 'Only in a second review of a ticket: the questions of the last review that the new comments answer.',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: { question: { type: 'string' }, by: { type: 'string' }, quote: { type: 'string' } },
+                    required: ['question', 'by', 'quote'],
+                },
+            },
+            testIdeas: { type: 'array', items: { type: 'string' } },
+            testsAtRisk: { type: 'array', items: { type: 'string' } },
+            suspectedCause: { type: 'string' },
+            confidence: { type: 'number', description: '0 to 1' },
+        },
+        required: ['outcome', 'headline', 'summary', 'risk', 'findings', 'openQuestions', 'testIdeas', 'testsAtRisk', 'confidence'],
+    },
+};
+const SCORE_TOOL = {
+    name: 'report_score',
+    description: 'Report how actionable the ticket is for QA.',
+    input_schema: {
+        type: 'object',
+        properties: { score: { type: 'integer', description: '0 to 100' }, reason: { type: 'string' } },
+        required: ['score', 'reason'],
+    },
+};
+const REVIEW_TOOL = {
+    name: 'report_review',
+    description: 'Report whether the outward action may go out without a human.',
+    input_schema: {
+        type: 'object',
+        properties: { ok: { type: 'boolean' }, escalate: { type: 'boolean' }, reason: { type: 'string' } },
+        required: ['ok', 'escalate', 'reason'],
+    },
+};
+function strings(v, max = 12) {
+    return Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x.trim() !== '').slice(0, max) : [];
+}
+/** The answeredQuestions of a reply, as strings of a safe size. The code that uses them checks them again (src/flows/answers.ts). */
+function answeredList(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.slice(0, 12).flatMap((x) => {
+        if (!x || typeof x !== 'object')
+            return [];
+        const a = x;
+        if (typeof a.question !== 'string' || typeof a.by !== 'string' || !a.question.trim() || !a.by.trim())
+            return [];
+        return [
+            { question: a.question.trim().slice(0, 500), by: a.by.trim().slice(0, 60), quote: typeof a.quote === 'string' ? a.quote.trim().slice(0, 600) : '' },
+        ];
+    });
+}
+function level(v, fallback = 'medium') {
+    return LEVELS.find((l) => l === v) ?? fallback;
+}
+export function normalizeVerdict(raw) {
+    const o = (raw && typeof raw === 'object' ? raw : {});
+    const findings = Array.isArray(o.findings)
+        ? o.findings.slice(0, 20).flatMap((f) => {
+            if (!f || typeof f !== 'object')
+                return [];
+            const x = f;
+            const item = { title: String(x.title ?? 'Finding'), detail: String(x.detail ?? ''), severity: level(x.severity) };
+            if (typeof x.file === 'string' && x.file)
+                item.file = x.file;
+            if (typeof x.line === 'number')
+                item.line = x.line;
+            return [item];
+        })
+        : [];
+    const verdict = {
+        outcome: OUTCOMES.find((x) => x === o.outcome) ?? 'needs_attention',
+        headline: String(o.headline ?? 'localdost finished a check').slice(0, 200),
+        summary: String(o.summary ?? ''),
+        risk: level(o.risk),
+        findings,
+        openQuestions: strings(o.openQuestions),
+        testIdeas: strings(o.testIdeas),
+        testsAtRisk: strings(o.testsAtRisk, 30),
+        confidence: typeof o.confidence === 'number' ? Math.max(0, Math.min(1, o.confidence)) : 0.5,
+    };
+    if (typeof o.suspectedCause === 'string' && o.suspectedCause)
+        verdict.suspectedCause = o.suspectedCause;
+    const answered = answeredList(o.answeredQuestions);
+    if (answered.length)
+        verdict.answeredQuestions = answered;
+    return verdict;
+}
+// ---------- Anthropic ----------
+export class AnthropicLlm {
+    // The key comes from liveEnv so a key saved in Setup works; undefined lets the SDK read the env.
+    client;
+    mock = new MockLlm();
+    constructor() {
+        this.client = new Anthropic({ apiKey: liveEnv.ANTHROPIC_API_KEY });
+    }
+    async analyze(req) {
+        const system = [{ type: 'text', text: systemFor(req.task), cache_control: { type: 'ephemeral' } }];
+        const messages = [{ role: 'user', content: renderAnalyzeInput(req) }];
+        const effort = req.task === 'ticket_review' || req.task === 'digest' ? 'medium' : 'high';
+        // Sonnet 5.5 rejects forced tool_choice, so the verdict tool is strict + auto and the
+        // system prompt requires it. One nudge turn covers the rare text-only reply.
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const res = await classifyThrown(() => this.client.messages.create({
+                model: mainModel(),
+                max_tokens: 16000,
+                system,
+                tools: [VERDICT_TOOL],
+                tool_choice: { type: 'auto' },
+                output_config: { effort },
+                messages,
+            }));
+            if (res.stop_reason === 'refusal')
+                break;
+            const call = res.content.find((b) => b.type === 'tool_use' && b.name === 'report_verdict');
+            if (call && res.stop_reason !== 'max_tokens')
+                return normalizeVerdict(call.input);
+            messages.push({ role: 'assistant', content: res.content });
+            messages.push({ role: 'user', content: 'Call report_verdict now with your verdict. Do not answer in text.' });
+        }
+        const fallback = await this.mock.analyze(req);
+        return {
+            ...fallback,
+            confidence: Math.min(fallback.confidence, 0.3),
+            summary: `${fallback.summary}\n\n_Model verdict unavailable; this is a rule-based fallback._`,
+        };
+    }
+    async score(ticket) {
+        try {
+            const res = await classifyThrown(() => this.client.messages.create({
+                model: fastModel(),
+                max_tokens: 512,
+                system: SCORE_SYSTEM,
+                tools: [SCORE_TOOL],
+                tool_choice: { type: 'tool', name: 'report_score' },
+                messages: [{ role: 'user', content: renderTicket(ticket) }],
+            }));
+            const call = res.content.find((b) => b.type === 'tool_use');
+            const score = Number(call?.input?.score);
+            if (Number.isFinite(score))
+                return Math.max(0, Math.min(100, Math.round(score)));
+        }
+        catch (err) {
+            rethrowIfUnavailable(err);
+            console.warn('[llm] score failed, using heuristic', err);
+        }
+        return this.mock.score(ticket);
+    }
+    async review(action, watch) {
+        const res = await classifyThrown(() => this.client.messages.create({
+            model: fastModel(),
+            max_tokens: 512,
+            system: REVIEW_SYSTEM,
+            tools: [REVIEW_TOOL],
+            tool_choice: { type: 'tool', name: 'report_review' },
+            messages: [{ role: 'user', content: renderActionForReview(action, watch) }],
+        }));
+        const call = res.content.find((b) => b.type === 'tool_use');
+        if (!call)
+            return { ok: true, escalate: true, reason: 'Reviewer returned no decision.', category: 'reviewer_unavailable' };
+        const x = (call.input ?? {});
+        // A decision without both booleans is no decision: never let a malformed review send a draft.
+        if (typeof x.ok !== 'boolean' || typeof x.escalate !== 'boolean')
+            return { ok: true, escalate: true, reason: 'Reviewer returned no decision.', category: 'reviewer_unavailable' };
+        return { ok: x.ok, escalate: x.escalate, reason: String(x.reason ?? '') };
+    }
+    async write(req) {
+        const res = await classifyThrown(() => this.client.messages.create({ model: mainModel(), max_tokens: 12000, system: req.system, messages: [{ role: 'user', content: req.prompt }] }, { timeout: req.timeoutMs ?? 180_000 }));
+        if (res.stop_reason === 'refusal')
+            throw new Error('the model refused');
+        const text = res.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('');
+        if (!text.trim())
+            throw new Error('the model returned no text');
+        return text;
+    }
+    async chat(req, onDelta, onTool) {
+        const system = [{ type: 'text', text: chatSystemFor(req.channel), cache_control: { type: 'ephemeral' } }];
+        if (req.context)
+            system.push({ type: 'text', text: req.context });
+        // "review PR 58 without posting a comment" asks for a review the tool cannot run as asked:
+        // hide the review tools for this turn so the model explains what a review does instead of queuing
+        // one. A refusal ("do not review TAD-3") or a condition ("after CI") hides them the same way.
+        const allTools = chatToolsFor(req.watch, req.reportId);
+        const held = reviewHasConditions(req.text) || reviewRequestHeld(req.text, req.watch);
+        const designHeld = designRequestHeld(req.text, req.watch);
+        const tools = held || designHeld
+            ? allTools.filter((t) => !(held && (t.name === 'review_pr' || t.name === 'review_ticket')) && !(designHeld && t.name === 'design_tests'))
+            : allTools;
+        const hints = req.watch ? presetHintsForWatch(req.watch) : '';
+        const context = req.watch
+            ? `${renderWatchForChat(req.watch)}${hints ? `\n${hints}` : ''}\nSelected dot id: ${req.watch.id}\n\n`
+            : 'No dot selected; tools default to all dots.\n\n';
+        const messages = [
+            ...req.history.map((h) => ({ role: h.role, content: h.content })),
+            { role: 'user', content: `${context}${req.text}` },
+        ];
+        let out = '';
+        const emit = (t) => {
+            out += t;
+            onDelta(t);
+        };
+        const ctx = { watch: req.watch, reportId: req.reportId };
+        // A ticket or PR link names the first lookup (KAT-98): run it now and hand the model the result,
+        // so the answer starts from that ticket or PR instead of from unrelated run history.
+        const first = plannedFirstTool(req.text, req.watch);
+        // The planned call is an assistant tool_use turn with no thinking block, and the API refuses thinking on a
+        // request that holds one. So a turn with a planned first call runs without thinking.
+        let thinkingOn = true;
+        if (first && tools.some((t) => t.name === first.name)) {
+            thinkingOn = false;
+            const id = 'toolu_localdost_planned_0';
+            let content;
+            let isError = false;
+            try {
+                content = JSON.stringify(modelFacing(await callChatTool(first.name, first.input, ctx, onTool)));
+            }
+            catch (err) {
+                content = String(err);
+                isError = true;
+            }
+            messages.push({ role: 'assistant', content: [{ type: 'tool_use', id, name: first.name, input: first.input }] });
+            messages.push({ role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content, ...(isError ? { is_error: true } : {}) }] });
+        }
+        const openViewStream = viewStreamOpener();
+        for (let turn = 0; turn < 8; turn++) {
+            const stream = this.client.messages.stream({
+                model: mainModel(),
+                max_tokens: 8000,
+                system,
+                tools,
+                output_config: { effort: 'low' },
+                // Summarized thinking is the model's own summary of its reasoning; only its text becomes step lines.
+                ...(thinkingOn ? { thinking: { type: 'adaptive', display: 'summarized' } } : {}),
+                messages,
+            });
+            stream.on('text', (delta) => emit(delta));
+            const told = new Set();
+            const tell = (b) => {
+                if (b.type !== 'thinking' || told.has(b.thinking))
+                    return;
+                told.add(b.thinking);
+                reportReasoning(b.thinking);
+            };
+            stream.on('contentBlock', tell);
+            // A compose_view call is written as JSON that arrives in pieces. The view goes to the client while it is written: its shell once the
+            // first node of the root has closed, then each node as it closes (docs/CHAT-UI.md, Composed views). The finished call replaces it.
+            const feeds = new Map();
+            stream.on('streamEvent', (ev) => {
+                try {
+                    if (ev.type === 'content_block_start' && ev.content_block.type === 'tool_use' && ev.content_block.name === COMPOSE_VIEW_TOOL) {
+                        const feed = openViewStream();
+                        if (feed)
+                            feeds.set(ev.index, feed);
+                    }
+                    else if (ev.type === 'content_block_delta' && ev.delta.type === 'input_json_delta')
+                        feeds.get(ev.index)?.feed(ev.delta.partial_json);
+                    else if (ev.type === 'content_block_stop')
+                        feeds.get(ev.index)?.end();
+                }
+                catch {
+                    /* the preview is not the view: the finished call still builds it */
+                }
+            });
+            const msg = await classifyThrown(() => stream.finalMessage());
+            msg.content.forEach(tell);
+            if (msg.stop_reason === 'refusal') {
+                emit(out ? '\n' : "I can't help with that request.");
+                break;
+            }
+            const uses = msg.content.filter((b) => b.type === 'tool_use');
+            if (msg.stop_reason !== 'tool_use' || uses.length === 0)
+                break;
+            messages.push({ role: 'assistant', content: msg.content });
+            const results = await Promise.all(uses.map(async (u) => {
+                if ((u.name === 'review_pr' || u.name === 'review_ticket' || u.name === 'design_tests') && !tools.some((t) => t.name === u.name)) {
+                    onTool(u.name, u.input);
+                    return { type: 'tool_result', tool_use_id: u.id, content: `${u.name} is not available for a request with conditions.`, is_error: true };
+                }
+                try {
+                    // A repeat of a call made this turn returns the first result and shows no second card.
+                    const value = await callChatTool(u.name, u.input, ctx, onTool);
+                    // The model reads the result with its id, so compose_view can name it (KAT-366).
+                    return { type: 'tool_result', tool_use_id: u.id, content: JSON.stringify(modelFacing(value)) };
+                }
+                catch (err) {
+                    return { type: 'tool_result', tool_use_id: u.id, content: String(err), is_error: true };
+                }
+            }));
+            messages.push({ role: 'user', content: results });
+            // A view that streamed and had no call to finish it (a repeat of a call, for one) leaves the client.
+            closeViewStreams();
+            if (out && !out.endsWith('\n'))
+                emit('\n');
+        }
+        return out.trim();
+    }
+}
+// ---------- Mock ----------
+const TEST_FILE = /(^|\/)(tests?|e2e|__tests__)\/|\.(spec|test)\.[cm]?[jt]sx?$/;
+function isTestFile(path) {
+    return TEST_FILE.test(path);
+}
+export function areaOf(path) {
+    const m = /(?:^|\/)src\/([^/]+)\//.exec(path);
+    return m ? m[1].toLowerCase() : null;
+}
+function specArea(file) {
+    return (file.split('/').pop() ?? file).replace(/\.(spec|test)\.[cm]?[jt]sx?$/, '').toLowerCase();
+}
+function firstLine(s) {
+    return ((s ?? '')
+        .split('\n')
+        .map((l) => l.trim())
+        .find(Boolean) ?? '');
+}
+function expectedReceived(error) {
+    if (!error)
+        return null;
+    const clean = error.replace(/\u001b\[[0-9;]*m/g, '');
+    const m = /Expected[^:\n]*:\s*"?([^"\n]+)"?\s*\n\s*Received[^:\n]*:\s*"?([^"\n]+)"?/i.exec(clean);
+    return m ? { expected: m[1].trim(), received: m[2].trim() } : null;
+}
+function addedLines(f, max = 3) {
+    if (!f?.patch)
+        return [];
+    return f.patch
+        .split('\n')
+        .filter((l) => l.startsWith('+') && !l.startsWith('+++') && l.slice(1).trim())
+        .slice(0, max)
+        .map((l) => l.slice(1).trim());
+}
+function ago(fromIso, to = Date.now()) {
+    const min = Math.max(0, Math.round((to - Date.parse(fromIso)) / 60000));
+    if (min < 60)
+        return `${min} min`;
+    const h = Math.round(min / 60);
+    return h < 48 ? `${h} h` : `${Math.round(h / 24)} days`;
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+const RISK_RULES = [
+    {
+        match: /discount|promo|coupon|loyalty|voucher/,
+        risk: {
+            title: 'Discount stacking order is undefined',
+            detail: 'Applying the loyalty discount before or after a promo code gives different totals. The ticket does not say which order wins or whether there is a cap.',
+            severity: 'high',
+        },
+        question: 'In what order do loyalty and promo discounts apply, and is there a maximum combined discount?',
+        ideas: [
+            'Cart of $120 with promo LOYAL10 and loyalty 5%: assert the total for both orders and confirm which one the spec wants',
+            'Promo code that already gives 100% off plus loyalty: total must not go below $0.00',
+        ],
+    },
+    {
+        match: /total|price|checkout|payment|currency|tax/,
+        risk: {
+            title: 'Rounding on stacked percentages',
+            detail: 'Two percentage discounts on the same subtotal produce fractional cents. Rounding per step versus once at the end changes the charged amount.',
+            severity: 'medium',
+        },
+        question: 'Do we round after each discount or once on the final total, and which rounding mode?',
+        ideas: [
+            'Subtotal $19.99 with 10% then 5% off: assert the exact cents shown at checkout and charged at payment',
+            'Checkout total shown on the page matches the amount sent to the payment provider',
+        ],
+    },
+    {
+        match: /loyalty|member|tier|account|guest|login/,
+        risk: {
+            title: 'Eligibility rules are unclear',
+            detail: 'The ticket does not say who counts as a loyalty member, whether guests qualify, or what happens when membership lapses mid-session.',
+            severity: 'medium',
+        },
+        question: 'Which customers are eligible, and what do guests see?',
+        ideas: [
+            'Guest checkout with a promo code: no loyalty discount line appears',
+            'Member whose tier expires between cart and checkout: total recalculates on the checkout page',
+        ],
+    },
+    {
+        match: /cart|basket|quantity/,
+        risk: {
+            title: 'Cart edits after discount',
+            detail: 'Changing quantity or removing items after a code is applied must recompute every discount line.',
+            severity: 'medium',
+        },
+        question: 'Should a code stay applied when the cart drops below its minimum?',
+        ideas: ['Apply a code, change quantity from 1 to 3: discount and total update without a reload'],
+    },
+    {
+        match: /upload|file|attachment|image/,
+        risk: { title: 'File limits not stated', detail: 'No size, type, or count limits are given for uploads.', severity: 'medium' },
+        question: 'What are the maximum file size and the allowed file types?',
+        ideas: ['Upload a file 1 byte over the limit: clear error, nothing stored'],
+    },
+    {
+        match: /email|notification|notify|sms/,
+        risk: { title: 'Notification content and timing', detail: 'The ticket does not define when the message is sent or what it contains.', severity: 'low' },
+        question: 'Which events trigger the notification, and is there a template?',
+        ideas: ['Trigger the event twice quickly: exactly one notification is sent'],
+    },
+    {
+        match: /permission|role|admin|access/,
+        risk: { title: 'Authorization gaps', detail: 'Roles that may perform the action are not listed.', severity: 'high' },
+        question: 'Which roles may do this, and what does a forbidden user see?',
+        ideas: ['Call the endpoint as a read-only user: 403 and no state change'],
+    },
+];
+const GENERIC_RISKS = [
+    {
+        title: 'Acceptance criteria are not testable as written',
+        detail: 'The criteria describe intent, not observable results, so two testers could pass and fail the same build.',
+        severity: 'medium',
+    },
+    {
+        title: 'No error or empty states described',
+        detail: 'The ticket covers the happy path only. Invalid input, network failure, and empty data are not covered.',
+        severity: 'medium',
+    },
+    { title: 'No rollout or migration notes', detail: 'Existing data and in-flight sessions may behave differently after release.', severity: 'low' },
+];
+const VAGUE = [
+    'should work',
+    'works correctly',
+    'correctly',
+    'properly',
+    'as expected',
+    'appropriate',
+    'seamless',
+    'user friendly',
+    'etc',
+    'and so on',
+    'fast',
+];
+// A comment that states a decision. The mock treats a question as answered when such a comment is about the same topic.
+const DECISION = /\b(decided|agreed|confirmed|the answer is|we will|we'll|the rule is|should be|must be)\b/i;
+/** How many different words of a rule a comment uses. The rule patterns are lists of topic words, so this is the topic overlap. */
+function topicHits(rule, text) {
+    const re = new RegExp(rule.match.source, 'g');
+    return new Set([...text.matchAll(re)].map((m) => m[0])).size;
+}
+/**
+ * The comments that answer a question of a risk rule (mock model only), by rule. A comment states a decision and answers
+ * one question at most: the rule whose topic words it uses most. When two rules tie, it answers neither, because asking a
+ * question again costs less than dropping one that nobody answered. The newest comment wins for a rule (comments come
+ * newest first).
+ */
+function answersFor(matched, req) {
+    const out = new Map();
+    for (const c of req.context?.comments ?? []) {
+        // A writer with no role in the repo can say anything, so such a comment never answers a question.
+        if (c.outsider)
+            continue;
+        // Only a sentence that is not a question can state a decision: "Which members should be eligible?" asks, it does not answer.
+        const decided = c.body.split(/(?<=[.!?])\s+|\n+/).filter((sentence) => !sentence.includes('?') && DECISION.test(sentence));
+        if (!decided.length)
+            continue;
+        const text = decided.join(' ').toLowerCase();
+        const scored = matched.map((rule) => ({ rule, hits: topicHits(rule, text) })).filter((x) => x.hits > 0);
+        const top = Math.max(0, ...scored.map((x) => x.hits));
+        const best = scored.filter((x) => x.hits === top);
+        if (best.length !== 1 || out.has(best[0].rule))
+            continue;
+        // The quote is the decision sentence that is about the question (the most topic words of its rule), so the line that says
+        // "this answers the question" shows the answer. A tie keeps the first.
+        const rule = best[0].rule;
+        const sentence = decided.reduce((a, b) => (topicHits(rule, b.toLowerCase()) > topicHits(rule, a.toLowerCase()) ? b : a));
+        const words = sentence.replace(/\s+/g, ' ').trim().split(' ');
+        // At most 15 words; a quote that ends a sentence keeps its full stop inside the quotation marks.
+        const quote = words
+            .slice(0, 15)
+            .join(' ')
+            .replace(/[,;:]$/, '');
+        const cut = words.length > 15 ? `${quote}...` : /[.!?]$/.test(quote) ? quote : `${quote}.`;
+        out.set(best[0].rule, { author: c.author, at: c.at.slice(0, 10), quote: cut });
+    }
+    return out;
+}
+function mockTicketVerdict(req) {
+    const t = req.ticket;
+    if (!t)
+        return infoVerdict('No ticket content was available to review.');
+    const text = `${t.title}\n${t.description}\n${t.acceptanceCriteria ?? ''}`.toLowerCase();
+    const matched = RISK_RULES.filter((r) => r.match.test(text));
+    const risks = matched.map((r) => r.risk);
+    for (const g of GENERIC_RISKS)
+        if (risks.length < 3)
+            risks.push(g);
+    const ac = (t.acceptanceCriteria ?? '').toLowerCase();
+    const vague = VAGUE.filter((v) => new RegExp(`\\b${v}\\b`).test(ac || text)).filter((v, _i, all) => !all.some((o) => o !== v && o.includes(v)));
+    // A question that a comment of the ticket already answers is not asked again; the summary names the comment (KAT-389).
+    const answered = answersFor(matched, req);
+    const open = matched.filter((r) => !answered.has(r));
+    const questions = [
+        ...vague.slice(0, 2).map((v) => `"${v[0].toUpperCase()}${v.slice(1)}": what does a tester see when it works? Give one example with real values.`),
+        ...open.map((r) => r.question),
+    ];
+    if (!t.acceptanceCriteria)
+        questions.unshift('There are no acceptance criteria. What must be true for this to be done?');
+    const ideas = matched.flatMap((r) => r.ideas).slice(0, 5);
+    if (!ideas.length)
+        ideas.push(`Happy path for "${t.title}" with valid input, then the same flow with each required field empty`);
+    const hits = req.codeHits ?? [];
+    const testsAtRisk = [...new Set(hits.filter((h) => isTestFile(h.path)).map((h) => h.path))];
+    const codePaths = [...new Set(hits.filter((h) => !isTestFile(h.path)).map((h) => h.path))].slice(0, 5);
+    const gaps = vague.length > 0 || !t.acceptanceCriteria;
+    const outQuestions = questions.slice(0, 5);
+    // The comment lists the questions, risks and test ideas itself. The summary holds only what those lines do not say.
+    const md = [];
+    // One line per answered question; a comment answers one question at most.
+    for (const a of answered.values()) {
+        md.push(`From the discussion: @${a.author} wrote on ${a.at}: "${a.quote}" That answers the question, so the review does not ask it again.`);
+    }
+    if (!t.acceptanceCriteria)
+        md.push('The ticket has no acceptance criteria, so two testers could pass and fail the same build.');
+    else if (vague.length)
+        md.push(`The acceptance criteria use ${vague
+            .slice(0, 2)
+            .map((v) => `"${v}"`)
+            .join(' and ')}. A tester cannot measure that, so each person reads it their own way.`);
+    if (testsAtRisk.length || codePaths.length) {
+        md.push('', '**Existing code and tests at risk**', ...testsAtRisk.map((p) => `- \`${p}\` (test)`), ...codePaths.map((p) => `- \`${p}\``));
+    }
+    return {
+        outcome: gaps ? 'needs_attention' : 'info',
+        headline: `${t.key}: ${risks.slice(0, 3).length} risks and ${outQuestions.length} open questions before this is ready to build`,
+        summary: md.join('\n'),
+        risk: risks.some((r) => r.severity === 'high') ? 'high' : 'medium',
+        findings: risks.slice(0, 3),
+        openQuestions: outQuestions,
+        testIdeas: ideas,
+        testsAtRisk,
+        confidence: 0.7,
+    };
+}
+function infoVerdict(headline, summary = headline) {
+    return { outcome: 'info', headline, summary, risk: 'low', findings: [], openQuestions: [], testIdeas: [], testsAtRisk: [], confidence: 0.5 };
+}
+// Infra problems: unreachable app, missing browser, crashed runner.
+const ENV_ERROR = /ECONNREFUSED|ENOTFOUND|ERR_CONNECTION|net::ERR|socket hang up|\b50[234]\b|Executable doesn't exist|browserType\.launch|playwright install|Browser closed|ENOSPC|out of memory/i;
+function mockTestVerdict(req) {
+    const r = req.report;
+    const diff = req.diff ?? [];
+    if (!r)
+        return infoVerdict('No test report was produced for this change.');
+    const changed = diff.filter((f) => !isTestFile(f.path));
+    const failed = r.cases.filter((c) => c.status === 'failed' || c.status === 'timedOut');
+    const flaky = r.cases.filter((c) => c.status === 'flaky');
+    const total = r.cases.length;
+    const table = `| Passed | Failed | Flaky | Skipped |\n|---|---|---|---|\n| ${r.passed} | ${r.failed} | ${r.flaky} | ${r.skipped} |`;
+    const areas = [...new Set(changed.map((f) => areaOf(f.path)).filter((a) => !!a))];
+    if (failed.length) {
+        const first = failed[0];
+        const culprit = changed.find((f) => areaOf(f.path) === specArea(first.file)) ?? changed[0];
+        const allEnv = failed.every((c) => ENV_ERROR.test(c.error ?? '') || c.title === 'Test run did not complete');
+        const selectorOnly = failed.every((c) => /locator\(|waiting for (locator|selector)|strict mode violation|resolved to 0 elements/i.test(c.error ?? '') && !expectedReceived(c.error));
+        const onlyTestsChanged = diff.length > 0 && changed.length === 0;
+        const outcome = allEnv ? 'environment_failure' : selectorOnly && onlyTestsChanged ? 'test_failure' : 'product_failure';
+        const findings = failed.slice(0, 5).map((c) => {
+            const er = expectedReceived(c.error);
+            const where = changed.find((f) => areaOf(f.path) === specArea(c.file)) ?? culprit;
+            const evidence = addedLines(where);
+            return {
+                title: `"${c.title}" failed${c.retries ? ` on all ${c.retries + 1} attempts` : ''}`,
+                detail: [
+                    er ? `Expected ${er.expected}, got ${er.received}.` : firstLine(c.error),
+                    where ? `Changed in this merge: ${where.path} (+${where.additions} -${where.deletions}).` : '',
+                    evidence.length ? `New lines: ${evidence.map((l) => `\`${l}\``).join(', ')}` : '',
+                ]
+                    .filter(Boolean)
+                    .join(' '),
+                severity: outcome === 'product_failure' ? 'high' : 'medium',
+                file: c.file,
+            };
+        });
+        const er = expectedReceived(first.error);
+        const label = outcome === 'product_failure' ? 'Product failure' : outcome === 'environment_failure' ? 'Environment failure' : 'Test failure';
+        const headline = outcome === 'environment_failure'
+            ? `${failed.length} of ${total} tests could not run (environment): ${firstLine(first.error)
+                .replace(/^Error:\s*/, '')
+                .slice(0, 80)}`
+            : // The headline is the page title a tester reads: the file of the suspected change sits in the summary below it.
+                `"${first.title}" fails after this change${er ? `: expected ${er.expected}, got ${er.received}` : ''}`;
+        const md = [
+            `### localdost: ${label.toLowerCase()}`,
+            `**${first.title}** (\`${first.file}\`) failed${first.retries ? ` ${first.retries + 1} times in a row, so this is not flakiness` : ''}.`,
+            er ? `- Expected \`${er.expected}\`, got \`${er.received}\`.` : `- ${firstLine(first.error) || 'See the run for the error.'}`,
+            culprit ? `- Suspected cause: \`${culprit.path}\` (+${culprit.additions} -${culprit.deletions}) in this change.` : '',
+            flaky.length ? `- Also flaky (passed on retry): ${flaky.map((c) => `"${c.title}"`).join(', ')}.` : '',
+            '',
+            table,
+        ].filter((l) => l !== '');
+        const verdict = {
+            outcome,
+            headline: headline.slice(0, 160),
+            summary: md.join('\n'),
+            risk: outcome === 'product_failure' ? 'high' : 'medium',
+            findings,
+            openQuestions: [],
+            testIdeas: culprit ? [`Add a unit test next to ${culprit.path} that covers the case "${first.title}" checks end to end`] : [],
+            testsAtRisk: [...new Set(failed.map((c) => c.file))],
+            confidence: outcome === 'product_failure' && culprit && areaOf(culprit.path) === specArea(first.file) ? 0.85 : 0.6,
+        };
+        if (culprit)
+            verdict.suspectedCause = `${culprit.path} changed in this merge`;
+        return verdict;
+    }
+    if (flaky.length) {
+        return {
+            outcome: 'flaky',
+            headline: `All tests passed, but ${flaky.map((c) => `"${c.title}"`).join(', ')} needed a retry`,
+            summary: [
+                `### localdost: passed with flaky tests`,
+                ...flaky.map((c) => `- \`${c.file}\` "${c.title}" passed on retry ${c.retries}. Saved to memory as flaky.`),
+                '',
+                table,
+            ].join('\n'),
+            risk: 'low',
+            findings: flaky.map((c) => ({
+                title: `Flaky: ${c.title}`,
+                detail: firstLine(c.error) || 'Failed once, passed on retry.',
+                severity: 'low',
+                file: c.file,
+            })),
+            openQuestions: [],
+            testIdeas: [],
+            testsAtRisk: flaky.map((c) => c.file),
+            confidence: 0.75,
+        };
+    }
+    const files = [...new Set(r.cases.map((c) => c.file))];
+    const uncovered = areas.filter((a) => !files.some((f) => specArea(f).includes(a)));
+    return {
+        outcome: 'pass',
+        // Skipped tests did not pass: "All 138 passed" with 53 skipped hid them (dogfood ledger).
+        headline: `${r.skipped ? `${r.passed} passed, ${r.skipped} skipped, 0 failed` : `All ${total} selected tests passed`}${areas.length ? ` for ${areas.join(', ')}` : ''}`,
+        summary: [
+            `### localdost: passed`,
+            // A skipped test did not run (KAT-402): the count is the tests that passed, and the skipped ones are said apart.
+            `Ran ${r.skipped ? r.passed : total} tests in ${files.map((f) => `\`${f}\``).join(', ') || 'the suite'} against ${r.baseUrl ?? 'the base URL'}.${r.skipped ? ` ${r.skipped} ${r.skipped === 1 ? 'was' : 'were'} skipped (${r.skipped === 1 ? 'it does' : 'they do'} not apply to this project).` : ''}`,
+            uncovered.length ? `- No spec covers ${uncovered.map((a) => `\`src/${a}/\``).join(', ')} directly; only smoke tests ran for it.` : '',
+            '',
+            table,
+        ]
+            .filter((l) => l !== '')
+            .join('\n'),
+        risk: uncovered.length ? 'medium' : 'low',
+        findings: uncovered.map((a) => ({
+            title: `No spec for ${a}`,
+            detail: `Changes under src/${a}/ were only covered by smoke tests.`,
+            severity: 'medium',
+        })),
+        openQuestions: [],
+        testIdeas: uncovered.map((a) => `Add a ${a}.spec.ts that covers the main ${a} flow`),
+        testsAtRisk: [],
+        confidence: 0.8,
+    };
+}
+function latestMerge(runs) {
+    return [...(runs ?? [])].filter((r) => r.kind === 'post_merge' && r.trigger).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+}
+function mockOutageVerdict(req) {
+    const ev = req.event;
+    const probe = ev?.probe;
+    const target = probe ? hostOf(probe.url) : (ev?.title ?? 'production');
+    const symptom = probe ? (probe.status ? `HTTP ${probe.status}` : (probe.error ?? 'no response')) : 'status page degraded';
+    const merge = latestMerge(req.recentRuns);
+    const pr = merge?.trigger?.pr;
+    const cause = merge ? `${pr ? `PR #${pr.number} ` : ''}"${merge.trigger?.title}" merged ${ago(merge.createdAt)} before the first failed probe` : undefined;
+    const brokeTests = merge?.verdict?.outcome === 'product_failure';
+    const md = [
+        `### Outage: ${target}`,
+        `- Symptom: ${symptom}${probe ? ` on ${probe.url}, ${probe.consecutiveFailures} checks in a row` : ''}.`,
+        cause
+            ? `- Leading suspect: ${cause}.${brokeTests ? ' Its post-merge run already reported a product failure.' : ''}`
+            : '- No merges in the last 24 h. Check infrastructure and third-party status pages first.',
+        '- Next: roll back the suspect or check the deploy logs, then watch for the recovery notice.',
+    ];
+    const verdict = {
+        outcome: 'needs_attention',
+        headline: `${target} is down (${symptom})${pr ? `; suspect PR #${pr.number}` : ''}`,
+        summary: md.join('\n'),
+        risk: 'high',
+        findings: [{ title: `${target} failing`, detail: `${symptom}${probe?.error ? `: ${probe.error}` : ''}`, severity: 'high' }],
+        openQuestions: cause ? [] : ['Was there a deploy or config change outside GitHub in the last hour?'],
+        testIdeas: ['Add a probe with expectText on the page body so a blank 200 also counts as down'],
+        testsAtRisk: [],
+        confidence: cause ? (brokeTests ? 0.7 : 0.55) : 0.25,
+    };
+    if (cause)
+        verdict.suspectedCause = cause;
+    return verdict;
+}
+function mockCiVerdict(req) {
+    // drop ANSI colours and the ISO timestamps GitHub prefixes to every log line
+    const log = (req.logTail ?? '').replace(/\u001b\[[0-9;]*m/g, '').replace(/^\d{4}-\d\d-\d\dT[\d:.]+Z ?/gm, '');
+    const lines = log.split('\n');
+    const pick = (re) => lines.find((l) => re.test(l))?.trim();
+    let outcome;
+    let decisive;
+    if ((decisive = pick(/ECONNREFUSED|ENOTFOUND|ETIMEDOUT|rate limit|No space left|out of memory|Killed|exit code 137|npm ERR! network|Could not resolve host|503 Service|Executable doesn't exist|browserType\.launch/i)))
+        outcome = 'environment_failure';
+    else if ((decisive = pick(/\bflaky\b|passed on retry|\d+ flaky/i)))
+        outcome = 'flaky';
+    else if ((decisive = pick(/waiting for (locator|selector)|resolved to 0 elements|strict mode violation|toBeVisible/i)) && !/Expected[^:]*:/.test(log))
+        outcome = 'test_failure';
+    else if ((decisive = pick(/Expected[^:]*:|AssertionError|toHaveText|toEqual|TypeError|ReferenceError|\d+ failed/i)))
+        outcome = 'product_failure';
+    else {
+        outcome = 'needs_attention';
+        decisive = pick(/error/i);
+    }
+    const er = expectedReceived(log);
+    const failingTest = pick(/✘|\[\w+\] ›|\d+\) .*spec\.[jt]s/);
+    const wf = req.event?.ci?.workflow ?? 'CI';
+    const next = {
+        product_failure: 'Fix the code; the test caught a real regression.',
+        test_failure: 'Update the selector or the test; the app looks fine.',
+        environment_failure: 'Re-run the job; nothing in the code needs to change.',
+        flaky: 'Re-run and quarantine the flaky spec.',
+        needs_attention: 'Read the full log; the tail is not conclusive.',
+        pass: '',
+        info: '',
+    };
+    return {
+        outcome,
+        headline: `${wf} failed: ${outcome.replace('_', ' ')}${er ? ` (expected ${er.expected}, got ${er.received})` : ''}`.slice(0, 160),
+        summary: [
+            `### CI triage: ${outcome.replace('_', ' ')}`,
+            decisive ? `Decisive line:\n\n\`\`\`\n${decisive.slice(0, 300)}\n\`\`\`` : 'No decisive line in the log tail.',
+            failingTest ? `- Failing test: ${failingTest.slice(0, 200)}` : '',
+            `- Next: ${next[outcome]}`,
+        ]
+            .filter(Boolean)
+            .join('\n'),
+        risk: outcome === 'product_failure' ? 'high' : 'medium',
+        findings: decisive ? [{ title: 'Decisive log line', detail: decisive.slice(0, 300), severity: outcome === 'product_failure' ? 'high' : 'medium' }] : [],
+        openQuestions: [],
+        testIdeas: [],
+        testsAtRisk: failingTest ? [failingTest.slice(0, 120)] : [],
+        confidence: outcome === 'needs_attention' ? 0.3 : 0.65,
+    };
+}
+function mockDigestVerdict(req) {
+    const runs = req.recentRuns ?? [];
+    const tests = runs.filter((r) => r.report);
+    const failing = runs.filter((r) => r.verdict && ['product_failure', 'test_failure', 'environment_failure', 'needs_attention'].includes(r.verdict.outcome));
+    const tickets = runs.filter((r) => r.kind === 'ticket_review');
+    const outages = runs.filter((r) => r.kind === 'outage');
+    const flaky = req.memory.filter((m) => m.kind === 'flaky_spec');
+    const passed = tests.reduce((n, r) => n + (r.report?.passed ?? 0), 0);
+    const failed = tests.reduce((n, r) => n + (r.report?.failed ?? 0), 0);
+    const md = [
+        `### Daily digest: ${req.watch.name}`,
+        failing.length ? '**Needs you today**' : '**Nothing needs you today.**',
+        ...failing.slice(0, 5).map((r) => `- ${r.verdict?.headline}`),
+        '',
+        `- ${tests.length} test runs: ${passed} passed, ${failed} failed.`,
+        `- ${tickets.length} tickets reviewed${tickets.length ? `: ${tickets.map((r) => r.trigger?.ticket?.key ?? r.trigger?.title).join(', ')}` : ''}.`,
+        `- ${outages.length} probe incidents.`,
+        flaky.length
+            ? `- Flaky specs on file: ${flaky
+                .slice(0, 5)
+                .map((m) => m.text)
+                .join('; ')}.`
+            : '- No flaky specs on file.',
+    ];
+    return {
+        outcome: failing.length ? 'needs_attention' : 'info',
+        headline: failing.length
+            ? `${failing.length} open problems; first: ${failing[0].verdict?.headline}`.slice(0, 160)
+            : `Quiet day: ${tests.length} runs, ${tickets.length} tickets, ${outages.length} incidents`,
+        summary: md.join('\n'),
+        risk: failing.length ? 'medium' : 'low',
+        findings: failing.slice(0, 5).map((r) => ({ title: r.verdict.headline, detail: `${r.kind} run ${r.id}`, severity: r.verdict.risk })),
+        openQuestions: [],
+        testIdeas: [],
+        testsAtRisk: flaky.map((m) => m.text.replace(/\s\(.*\)$/, '')),
+        confidence: 0.9,
+    };
+}
+const SECRET = /(ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|sk-ant-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|password\s*[:=]\s*\S+)/i;
+const INJECTION = /ignore (all |any )?(previous|prior|above) instructions|disregard (the|your) (rules|instructions)|you are now/i;
+const KIND_WORDS = {
+    run_tests: ['run tests', 'rerun'],
+    check_run: ['check run', 'status check'],
+    pr_comment: ['pr comment', 'comment on pr', 'comment on pull'],
+    ticket_comment: ['ticket', 'jira', 'linear', 'issue'],
+    ticket_status: ['ticket status', 'change status', 'move the ticket', 'transition'],
+    push_notify: ['notify', 'page me', 'push', 'wake'],
+    open_pr: ['open pr', 'open a pr', 'pull request', 'open prs'],
+    revert: ['revert', 'roll back', 'rollback'],
+    mcp_tool: ['tool', 'mcp'],
+    slack_post: ['slack', 'post to channel'],
+    report_edit: ['report', 'test plan', 'edit the page'],
+    file_defect: ['defect', 'file a bug', 'open an issue', 'file an issue'],
+    issue_create: ['defect', 'file a bug', 'create an issue', 'open an issue', 'file an issue'],
+    case_retire: ['retire a case', 'retire the case', 'obsolete test'],
+};
+function chunks(text) {
+    return text.match(/\S+\s*|\s+/g) ?? [text];
+}
+/** Plain reply for a ticket or PR tool result, for the rule-based chat and the CLI fallbacks (KAT-98). */
+export function replyForPlannedTool(name, value) {
+    const v = (value && typeof value === 'object' ? value : {});
+    if (typeof v.error === 'string')
+        return v.error;
+    const list = (x) => (Array.isArray(x) ? x.map(String) : []);
+    if (name === 'get_ticket') {
+        const last = v.lastReview;
+        return [
+            `${v.key}: ${v.title}${v.type ? ` (${v.type}${v.priority ? `, ${v.priority}` : ''})` : ''}.`,
+            v.acceptanceCriteria ? 'It has acceptance criteria.' : 'It has no acceptance criteria.',
+            last ? `My last review: ${last.headline ?? 'no headline'}.` : 'I have not reviewed it yet. Say "check it" and I will.',
+        ].join(' ');
+    }
+    if (name === 'design_tests') {
+        if (v.duplicate)
+            return `I am already designing tests for ${v.title}. The run card updates when it finishes.`;
+        if (v.status === 'queued' || v.status === 'running')
+            return `I started designing tests for ${v.title}. The run card updates when it finishes.`;
+        return `${v.line ?? 'Test design finished'} for ${v.ticket}. They are drafts: a person marks a case ready on the Test cases page.`;
+    }
+    if (name === 'review_ticket') {
+        if (v.duplicate)
+            return `I am already reviewing ${v.title}. The result lands on the run card.`;
+        if (v.status === 'queued' || v.status === 'running')
+            return `I started a review of ${v.title}. The run card updates when it finishes.`;
+        const risks = list(v.risks);
+        const qs = list(v.openQuestions);
+        return [
+            `${v.headline ?? `Reviewed ${v.title}`}.`.replace(/\.\.$/, '.'),
+            risks.length ? `Top risk: ${risks[0].replace(/^\w+: /, '')}.` : '',
+            qs.length ? `First open question: ${qs[0]}` : '',
+            v.comment === 'pending_approval'
+                ? 'My comment draft waits for your approval.'
+                : v.comment === 'executed'
+                    ? 'I posted the review as a comment.'
+                    : v.comment === 'none'
+                        ? ''
+                        : 'Your rules did not let me post the comment.',
+        ]
+            .filter(Boolean)
+            .join(' ');
+    }
+    if (name === 'review_pr') {
+        if (v.duplicate)
+            return `I am already reviewing that: ${v.title}. The result lands here and on the PR when it finishes.`;
+        return `Queued a ${v.kind === 'pr_check' ? 'PR check' : 'post-merge review'} for ${v.title}. The result lands here, and on the PR when there is one.`;
+    }
+    return JSON.stringify(value).slice(0, 300);
+}
+export class MockLlm {
+    async analyze(req) {
+        switch (req.task) {
+            case 'post_merge':
+            case 'pr_check':
+                return mockTestVerdict(req);
+            case 'ticket_review':
+                return mockTicketVerdict(req);
+            case 'outage':
+                return mockOutageVerdict(req);
+            case 'ci_failure':
+                return mockCiVerdict(req);
+            case 'digest':
+                return mockDigestVerdict(req);
+        }
+    }
+    async score(t) {
+        const desc = t.description ?? '';
+        const ac = t.acceptanceCriteria ?? '';
+        let s = 15;
+        if (t.title.trim().split(/\s+/).length >= 4)
+            s += 10;
+        if (desc.length > 60)
+            s += 10;
+        if (desc.length > 200)
+            s += 15;
+        if (ac.length > 0)
+            s += 15;
+        if (ac.length > 120)
+            s += 10;
+        if (t.type)
+            s += 5;
+        if (t.priority)
+            s += 5;
+        if (t.labels?.length)
+            s += 5;
+        const vague = VAGUE.filter((v) => new RegExp(`\\b${v}\\b`, 'i').test(`${desc}\n${ac}`)).length;
+        s -= Math.min(20, vague * 7);
+        return Math.max(0, Math.min(100, s));
+    }
+    async review(action, watch) {
+        if (SECRET.test(action.body) || SECRET.test(action.title))
+            return { ok: false, escalate: true, reason: 'The draft contains what looks like a credential.', category: 'secret_or_personal_data' };
+        if (INJECTION.test(action.body))
+            return { ok: true, escalate: true, reason: 'The draft repeats instruction-like text from untrusted content.', category: 'untrusted_instruction' };
+        if (action.kind === 'revert' || action.kind === 'open_pr')
+            return { ok: true, escalate: true, reason: `A ${action.kind.replace('_', ' ')} changes the codebase; a person should confirm.`, category: 'destructive' };
+        const mustNot = (watch.mustNot ?? '').toLowerCase();
+        const hit = KIND_WORDS[action.kind].find((w) => mustNot.includes(w));
+        if (hit)
+            return { ok: true, escalate: true, reason: `The watch says it must not: "${watch.mustNot.trim()}".`, category: 'must_not_rule' };
+        // Length is a code check in gate() (rules.ts deterministicReview), not a judgement of the reviewer.
+        return { ok: true, escalate: false, reason: 'No credentials, no rule conflicts, evidence included.' };
+    }
+    async chat(req, onDelta, onTool) {
+        const text = req.text.toLowerCase();
+        const ctx = { watch: req.watch, reportId: req.reportId };
+        const call = async (name, input = {}) => {
+            const v = await callChatTool(name, input, ctx, onTool);
+            // A lookup the turn already made (the CLI tool loop before a fallback) comes back wrapped.
+            return v && typeof v === 'object' && v.repeated ? v.result : v;
+        };
+        const memoryReply = async () => {
+            const items = (await call('get_memory'));
+            return items.length
+                ? `I remember ${items.length} things. ${items
+                    .slice(0, 4)
+                    .map((m) => `${m.kind.replace('_', ' ')}: ${m.text}`)
+                    .join('. ')}.`
+                : 'My memory for this dot is empty.';
+        };
+        let reply;
+        const planned = plannedFirstTool(req.text, req.watch);
+        // A ticket or PR link answers first (KAT-98), then a review request; both win over a page edit.
+        if (planned) {
+            reply = replyForPlannedTool(planned.name, await call(planned.name, planned.input));
+        }
+        else if (reviewIntent(req.text)) {
+            const target = reviewIntent(req.text);
+            const res = (await call('review_pr', target));
+            // A lead sends the review to the member whose job it is and says so (KAT-405).
+            const asked = res.routedTo && res.ask ? `Asked ${res.routedTo} to ${res.ask}. ` : '';
+            reply = res.error
+                ? res.error
+                : res.choices
+                    ? `${res.note ?? 'More than one dot fits.'} ${res.choices.map((c) => c.name ?? c.repo).join(', ')}.`
+                    : res.duplicate
+                        ? `${asked}I am already reviewing that: ${res.title}. The result lands here and on the PR when it finishes.`
+                        : `${asked}Queued a ${res.kind === 'pr_check' ? 'PR check' : 'post-merge review'} for ${res.title}. The result lands here, and on the PR when there is one.`;
+        }
+        else if (req.watch?.kind === 'lead' && /\b(?:team|how are we|how is everyone|does anything need me)\b/.test(text)) {
+            // A lead's question about the whole team: one status word and the member that set it (KAT-405).
+            const res = (await call('team_status'));
+            reply = res.error ?? `The team is ${String(res.status ?? 'unknown').toLowerCase()}. ${res.reason ?? ''}`.trim();
+        }
+        else if (req.reportId && /\b(add|append|edit|update|change|propose|rewrite)\b/.test(text)) {
+            // Rule-based page edit: append the request as an open task so the approval flow can be tried offline.
+            const page = getReport(req.reportId);
+            const item = req.text.replace(/^.*?\b(add|append)\b\s*/i, '').trim() || req.text.trim();
+            const markdown = `${(page?.markdown ?? '').replace(/\s+$/, '')}\n\n- [ ] ${item}\n`;
+            const res = (await call('propose_report_edit', { markdown, note: `Add task: ${item.slice(0, 60)}` }));
+            reply =
+                res.error ??
+                    (res.status === 'pending_approval'
+                        ? 'I drafted the edit. It adds the item as an open task; approve it on the card to save the page.'
+                        : res.status === 'executed'
+                            ? 'Done, the page is updated.'
+                            : 'Your rules did not let me change the page.');
+        }
+        else if (/^\s*(?:what|which|do you|did you|show|list|tell me)\b[^.!]*\b(?:remember|memory|memories)\b/.test(text)) {
+            // A question about what the dot remembers reads the notes; it is not a note to keep.
+            reply = await memoryReply();
+        }
+        else if (/\b(remember|note that|keep in mind)\b/.test(text)) {
+            const body = req.text.replace(/^.*?\b(remember|note that|keep in mind)\b\s*(that\s*)?/i, '').trim() || req.text;
+            const res = (await call('add_memory', { text: body, kind: /flaky/.test(text) ? 'flaky_spec' : 'note' }));
+            reply = res.saved ? `Saved. I will remember: "${body}".` : (res.error ?? 'I could not save that.');
+        }
+        else if (/\b(re-?run|run (the )?(quick )?(tests|smoke|suite)|test again|run again)\b/.test(text)) {
+            const grep = /\b(smoke|quick)\b/.test(text) ? '@smoke' : /checkout/.test(text) ? 'checkout' : undefined;
+            const res = (await call('rerun_tests', { grep }));
+            const asked = res.routedTo && res.ask ? `Asked ${res.routedTo} to ${res.ask}. ` : '';
+            reply = res.queued
+                ? `${asked}Queued a run of ${grep === '@smoke' ? 'the quick tests' : grep ? `the ${grep} tests` : 'the tests'} for ${res.dot}. I will report back here and on your phone if anything fails.`
+                : (res.error ?? res.reason ?? 'Nothing queued.');
+        }
+        else if (asksForComposedView(req.text)) {
+            // A question that needs several blocks, or numbers no tool gives directly: the rows, then a composed view (KAT-366).
+            reply = (await mockComposedReply(req.text, call)) ?? 'I could not build that view.';
+        }
+        else if (/\bpass(?:ing)?[\s-]?rate\b|\bhow (?:are|is) the tests (?:doing|going)\b/.test(text)) {
+            const res = (await call('pass_rate'));
+            reply = res.error ?? res.finding ?? res.note ?? 'No test run finished in the last 7 days.';
+        }
+        else if (/\bflaky\b.*\bspecs?\b|\bspecs?\b.*\bflaky\b|\bflaky tests?\b.*\bby\b/.test(text)) {
+            const res = (await call('flaky_by_spec'));
+            reply = res.error ?? res.finding ?? res.note ?? 'No test passed only on a retry.';
+        }
+        else if (/\b(test\s+cases?|cases)\b/.test(text)) {
+            const requirement = /\b(?!TC-)[A-Z][A-Z0-9_]{0,19}-\d{1,9}\b/.exec(req.text)?.[0];
+            const res = (await call('list_cases', requirement ? { requirement } : {}));
+            reply = res.error
+                ? res.error
+                : !res.count
+                    ? `No test cases${requirement ? ` for ${requirement}` : ''} yet. Add them on the Test cases page.`
+                    : `${res.count} test ${res.count === 1 ? 'case' : 'cases'}${requirement ? ` for ${requirement}` : ''}, with the latest result of each.`;
+        }
+        else if (/\b(?:ongoing work|what(?:'s| is) going on|what(?:'s| is) happening)\b/.test(text)) {
+            // The three lookups the chat prompt names for "what is the ongoing work": open PRs, runs working now, drafts that wait.
+            const prs = (await call('open_prs'));
+            const running = (await call('runs_in_progress'));
+            const waiting = (await call('pending_approvals'));
+            const n = (c) => Number(c.count ?? 0);
+            reply = `${n(prs)} pull request${n(prs) === 1 ? ' is' : 's are'} open. ${n(running)} run${n(running) === 1 ? ' is' : 's are'} running now. ${n(waiting)} draft${n(waiting) === 1 ? ' waits' : 's wait'} for your approval.`;
+        }
+        else if (/\bdefects?\b|\bsince the last merge\b/.test(text)) {
+            const res = (await call('recent_defects', /\blast merge\b/.test(text) ? { sinceLastMerge: true } : {}));
+            const first = res.defects?.[0];
+            reply = res.error
+                ? res.error
+                : !res.count
+                    ? 'No defects found in that time.'
+                    : `${res.count} ${res.count === 1 ? 'problem' : 'problems'} found: ${first?.headline ?? first?.trigger ?? 'a failed run'}${res.count > 1 ? `, and ${res.count - 1} more` : ''}.`;
+        }
+        else if (/\b(approv\w*|waiting|pending|inbox)\b/.test(text)) {
+            const res = (await call('pending_approvals'));
+            reply = res.error
+                ? res.error
+                : !res.count
+                    ? 'Nothing waits for your approval.'
+                    : `${res.count} waiting for your approval: ${(res.approvals ?? [])
+                        .slice(0, 3)
+                        .map((a) => a.title)
+                        .join('; ')}.`;
+        }
+        else if (/\b(prod|production|up|down|outage|probe|status)\b/.test(text)) {
+            const res = (await call('probe_status'));
+            if (!res.probes.length)
+                reply = res.note ?? 'No probe results yet.';
+            else {
+                const down = res.probes.filter((p) => p.down === true || p.status === 'down' || Number(p.consecutiveFailures ?? 0) >= 3);
+                const describe = (p) => `${hostOf(String(p.url ?? 'probe'))}${(p.lastStatus ?? p.status) ? ` (last ${p.lastStatus ?? p.status})` : ''}`;
+                reply = down.length
+                    ? `${down.length} of ${res.probes.length} probes are failing: ${down.map(describe).join(', ')}.`
+                    : `Yes, production is up. ${res.probes.length === 1 ? 'The probe' : `All ${res.probes.length} probes`} passed the last check.`;
+            }
+        }
+        else if (/\b(ticket|jira|linear|story|refinement)\b/.test(text)) {
+            const rows = (await call('list_tickets_reviewed', { limit: 3 }));
+            if (!rows.length)
+                reply = 'I have not reviewed any tickets yet.';
+            else {
+                const t = rows[0];
+                reply = [
+                    `Latest: ${t.headline ?? t.ticket}.`,
+                    t.risks?.length ? `Top risk: ${t.risks[0]}.` : '',
+                    t.openQuestions?.length ? `First open question: ${t.openQuestions[0]}` : '',
+                    t.commentStatus === 'pending_approval' ? 'My comment is waiting for your approval in the Inbox.' : '',
+                ]
+                    .filter(Boolean)
+                    .join(' ');
+            }
+        }
+        else if (/\b(memory|flaky|remember\?)\b/.test(text)) {
+            reply = await memoryReply();
+        }
+        else {
+            // default covers "what broke today?" and general status questions
+            const all = (await call('list_runs', { sinceHours: 24, limit: 20 }));
+            const problems = all.runs.filter((r) => r.outcome && !['pass', 'info'].includes(r.outcome));
+            if (!all.count)
+                reply = 'Nothing ran in the last 24 hours.';
+            else if (!problems.length)
+                reply = `Nothing broke today. ${all.count} runs in the last 24 hours, all clean.`;
+            else {
+                const lines = problems.slice(0, 3).map((r) => `${r.headline ?? r.trigger}${r.pendingApprovals ? ' (waiting on your approval)' : ''}`);
+                // A real Markdown list, one item per line: the chat shows it as a list, not as one paragraph with "1." inline.
+                reply = `${problems.length} of ${all.count} runs in the last 24 hours need attention:\n\n${lines.map((l, i) => `${i + 1}. ${l}`).join('\n')}`;
+            }
+        }
+        for (const c of chunks(reply)) {
+            onDelta(c);
+            await new Promise((r) => setTimeout(r, 12));
+        }
+        return reply;
+    }
+}
+//# sourceMappingURL=llm.js.map