tinybeeai 0.0.0-stage → 0.16.1

package/dist/agent/chat.js

@@ -0,0 +1,1703 @@
+// Chat tools, their executor, and the entry point the HTTP API calls.
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { get, insert, list, newId } from '../db.js';
+import { subscribe } from '../events.js';
+import { enqueue } from '../queue.js';
+import { bindingsFor, callConnectionTool, isMcpToolName, toolsForWatch } from '../connections/index.js';
+import { getReport, proposeReportEditAction, reportContextFor, REPORT_EDIT_TOOL, scrubReportEdit } from '../reports/index.js';
+import { recordAsk, recordAskForJob } from '../updates/asks.js';
+import { liveJobId } from '../ticket-supersede.js';
+import { parseChatBlock } from '../chat-blocks.js';
+import { BLOCK_LOOKUP_TOOLS, blocksFromToolResult } from './chat-tool-blocks.js';
+import { flakyBySpecBlocks, passRateBlocks } from '../chat-stats.js';
+import { TEST_RESULT_KINDS, TEST_RESULT_STATUSES, testResultRows } from '../chat-results.js';
+import { COMPOSE_VIEW_DEFINITION, COMPOSE_VIEW_TOOL, ResultRegistry, foreignDotOf, foreignSourceLine, refuseResult, VIEW_SOURCE_TOOLS, ViewStream, composeView, holdRows, holdViewBlocks, rowsSummary, tagResult, } from './chat-views.js';
+import { casesForTicket, designedCasesHref, designedLine } from '../flows/testDesign.js';
+import { isLead, membersOf, teamIds } from '../lead.js';
+import { dispatchLeadTool, leadChatTools, releaseBlock, releaseText } from './chat-lead.js';
+import { releaseCallFor } from '../lead-release.js';
+import { pickChatView } from './chat-view.js';
+import { buildTriageBlock, triageLine, triageWindowOf } from './triage.js';
+import { getLlm } from './llm.js';
+import { ModelUnavailableError } from './model-errors.js';
+import { capLine, capState, collectModelCalls, tokensOfCalls, withModelContext } from '../model-usage.js';
+import { withReasoning } from './reasoning.js';
+import { scrubEcho, teamNotes } from './team-notes.js';
+import { addMemory, listMemory } from './memory.js';
+import { gate } from './rules.js';
+import { addStep, finishRun, startRun } from './runs.js';
+import { parseReviewTarget, requestReview } from '../review/on-demand.js';
+import { fetchTicketRef, findTicketRefs, parseTicketInput, requestTestDesign, requestTicketReview } from '../review/ticket-on-demand.js';
+import { config, liveEnv } from '../config.js';
+import { PHONE_BLOCKED_MESSAGE } from '../phone/auth.js';
+import { githubFor } from '../integrations/github.js';
+import { hasAppRepo, watchRepos } from '../repos.js';
+import { renderRefs } from '../refs.js';
+import { buildObjectCard, objectOfCard, refKey, ticketToCard } from '../object-cards.js';
+import { objectLinksIn } from '../object-links.js';
+import { CaseInputError, casesBlock, listCases } from '../cases.js';
+/** Added to the description of every lookup tool whose result the chat shows as a list (docs/CHAT-UI.md). */
+const LIST_TOOL_NOTE = ' The chat shows the rows as a list the person can act on, so write one or two sentences about them and do not repeat every row. Set context to true when you read this only to decide what to do next; the chat then shows no list.';
+/**
+ * get_ticket reads a ticket and shows no list. It shows the review the dot wrote for the ticket only when the
+ * person asks about that review, and a call marked `context` never does (docs/CHAT-UI.md).
+ */
+const TICKET_TOOL_NOTE = ' The chat shows the review the dot wrote for the ticket only when the person asks about that review. Set context to true when you read the ticket only to decide what to do next, such as before you review it or design test cases for it; the chat then shows no review.';
+const TICKET_CONTEXT_PROPERTY = {
+    type: 'boolean',
+    description: 'True when you read the ticket only to decide what to do next, not to answer the question. The chat then shows no review of it.',
+};
+const CONTEXT_PROPERTY = {
+    type: 'boolean',
+    description: 'True when you read this only to decide what to do next, not to answer the question. The chat then shows no list.',
+};
+/**
+ * The lookup tools that answer with a block take an optional `context` flag, so a lookup the model makes only to
+ * choose its next step stays on the collapsed tool line and shows no list (KAT-136, KAT-133).
+ */
+function withContextFlag(tools) {
+    return tools.map((t) => {
+        const lookup = BLOCK_LOOKUP_TOOLS.includes(t.name);
+        if (!lookup && t.name !== 'get_ticket')
+            return t;
+        return {
+            ...t,
+            description: `${t.description ?? ''}${lookup ? LIST_TOOL_NOTE : TICKET_TOOL_NOTE}`,
+            input_schema: {
+                ...t.input_schema,
+                properties: {
+                    ...(t.input_schema.properties ?? {}),
+                    context: lookup ? CONTEXT_PROPERTY : TICKET_CONTEXT_PROPERTY,
+                },
+            },
+        };
+    });
+}
+export const CHAT_TOOLS = withContextFlag([
+    {
+        name: 'list_runs',
+        description: 'List recent runs (test runs, ticket reviews, outages, CI triage, digests), newest first, with outcome and headline.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string', description: 'Watch id. Omit for the selected dot, or all dots when none is selected.' },
+                kind: { type: 'string', enum: ['pr_check', 'post_merge', 'ci_failure', 'ticket_review', 'outage', 'recovery', 'digest', 'rerun', 'nightly_run'] },
+                onlyProblems: { type: 'boolean', description: 'Only runs whose outcome is not pass or info.' },
+                sinceHours: { type: 'number', description: 'Look back this many hours. Default 24.' },
+                limit: { type: 'integer', description: 'Max rows. Default 10.' },
+            },
+        },
+    },
+    {
+        name: 'get_run',
+        description: 'Full detail of one run: steps, failing tests with errors, verdict, and outward actions with their gate result.',
+        input_schema: { type: 'object', properties: { runId: { type: 'string' } }, required: ['runId'] },
+    },
+    {
+        name: 'list_tickets_reviewed',
+        description: 'Tickets this dot reviewed recently, with risks and open questions.',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' }, limit: { type: 'integer' } } },
+    },
+    {
+        name: 'rerun_tests',
+        description: 'Queue a new test run for a dot. Optionally limit to a grep pattern or spec files.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string' },
+                grep: { type: 'string', description: 'Playwright --grep pattern, e.g. @smoke or checkout.' },
+                specs: { type: 'array', items: { type: 'string' } },
+            },
+        },
+    },
+    {
+        name: 'review_pr',
+        description: 'Ask the dot to review a pull request, a commit, or a commit range now. An open PR gets the PR check (sticky comment and check); a merged PR, a commit, or a range gets the post-merge review. Comments and checks follow the dot rules, and the review starts now, so do not call it when the person asks for a condition the tool cannot honor (no comment, a later time, a different rule); say what the review will do instead. Pass exactly one of pr, sha, or base with head.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string' },
+                pr: { type: 'integer', description: 'PR number.' },
+                repo: { type: 'string', description: 'owner/name when the PR came as a link. It must be the dot repo.' },
+                sha: { type: 'string', description: 'Commit sha, 7 to 40 hex characters.' },
+                base: { type: 'string', description: 'Range start: a sha or branch.' },
+                head: { type: 'string', description: 'Range end: a sha or branch.' },
+            },
+        },
+    },
+    {
+        name: 'get_memory',
+        description: 'What the dot remembers: flaky specs, environment quirks, conventions, decisions, notes.',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' } } },
+    },
+    {
+        name: 'add_memory',
+        description: 'Save something the user wants the dot to remember.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string' },
+                text: { type: 'string' },
+                kind: { type: 'string', enum: ['flaky_spec', 'env_quirk', 'convention', 'decision', 'note'] },
+            },
+            required: ['text'],
+        },
+    },
+    {
+        name: 'probe_status',
+        description: 'Current production probe state per URL: up or down, last status code, consecutive failures.',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' } } },
+    },
+    {
+        name: 'list_cases',
+        description: "The dot's stored test cases with their latest result: key (TC-12), title, kind, priority, status, requirements, and spec file. Filter by a requirement key such as SHOP-12, a status, or a kind. The chat shows the cases as a list the person can tick and run, so do not repeat every row in the answer.",
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string' },
+                requirement: { type: 'string', description: 'Requirement key or ref, e.g. SHOP-12 or owner/name#12.' },
+                status: { type: 'string', enum: ['draft', 'ready', 'retired', 'all'], description: 'Default: draft and ready.' },
+                kind: { type: 'string', enum: ['manual', 'playwright', 'aivision'] },
+            },
+        },
+    },
+    {
+        name: 'get_ticket',
+        description: 'Read one ticket through the connected tracker: title, type, priority, description, acceptance criteria, and the last review this dot wrote for it. Pass a Jira, Linear, or GitHub issue URL, or a key such as SHOP-12. Call it first when the person asks about a ticket.',
+        input_schema: {
+            type: 'object',
+            properties: { dotId: { type: 'string' }, ticket: { type: 'string', description: 'Ticket URL or key.' } },
+            required: ['ticket'],
+        },
+    },
+    {
+        name: 'review_ticket',
+        description: 'Review a ticket now, the way the dot reviews a new ticket: risks, open questions, acceptance criteria gaps, test ideas, and a comment draft that follows the dot rules (ask first by default). Pass a Jira, Linear, or GitHub issue URL, or a key. Use it when the person asks to check or review a ticket.',
+        input_schema: {
+            type: 'object',
+            properties: { dotId: { type: 'string' }, ticket: { type: 'string', description: 'Ticket URL or key.' } },
+            required: ['ticket'],
+        },
+    },
+    {
+        name: 'design_tests',
+        description: 'Design manual test cases for a ticket now: the dot reads the ticket, uses its last review (or analyzes the ticket), and stores the cases as drafts linked to the ticket. Nothing is posted anywhere. Pass a Jira, Linear, or GitHub issue URL, or a key. The chat shows the designed cases as a card, so do not repeat every row. Use it when the person asks to design, write, or draft test cases for a ticket. Never call it for a request that says not to, or to wait.',
+        input_schema: {
+            type: 'object',
+            properties: { dotId: { type: 'string' }, ticket: { type: 'string', description: 'Ticket URL or key.' } },
+            required: ['ticket'],
+        },
+    },
+    {
+        name: 'pending_approvals',
+        description: 'What waits for a person to approve: comment drafts, checks, report edits, with what each is about and how long it has waited. Oldest wait first. Use it for "what is waiting for my approval".',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' }, limit: { type: 'integer' } } },
+    },
+    {
+        name: 'open_prs',
+        description: 'Open pull requests in the repo each dot watches, read from GitHub: number, title, author, link, last update. Use it for "what is the ongoing work" or "which PRs are open".',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' }, limit: { type: 'integer', description: 'Max PRs per repo. Default 10.' } } },
+    },
+    {
+        name: 'runs_in_progress',
+        description: 'Runs working right now and jobs queued behind them, with how long each has run. Use it for "what is running" or "what is the ongoing work".',
+        input_schema: { type: 'object', properties: { dotId: { type: 'string' } } },
+    },
+    {
+        name: 'recent_defects',
+        description: 'Runs that found a real problem (failing tests, product failures, high risks), newest first, with the failing tests and the suspected cause. Use it for "what broke" or "what broke since the last merge".',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string' },
+                sinceLastMerge: { type: 'boolean', description: 'Start at the latest post-merge run instead of a time window.' },
+                sinceHours: { type: 'number', description: 'Look back this many hours. Default 168 (one week).' },
+                limit: { type: 'integer', description: 'Max rows. Default 8.' },
+            },
+        },
+    },
+    {
+        name: 'pass_rate',
+        description: 'The test pass rate for the last 7 days against the week before, with tests run, failed, and flaky, as a row of number tiles and a line chart by day. The answer shows the tiles and chart itself, so write one sentence about them and do not list the numbers. Use it for "pass rate this week" or "how are the tests doing".',
+        input_schema: {
+            type: 'object',
+            properties: { dotId: { type: 'string', description: 'Watch id. Omit for the selected dot, or all dots when none is selected.' } },
+        },
+    },
+    {
+        name: 'test_results',
+        description: 'Test results of finished runs, one row per test per run, for a composed view (compose_view) that groups, counts, and compares them: by hour of day, by branch, by spec, before and after a merge. Rows have at (the run time, ISO), runId, dot, branch, kind, suite (the spec file), file, title, status (passed, failed, flaky, timedOut), durationMs, and retries; skipped tests are left out. You get the columns, a count, and a sample; the view reads all the rows by this result\'s resultId. Filter here, not in the view: days, branch, status, spec, run kind. Use splitAt last_merge to add a period column (before or after the newest merge into the default branch) for "since the last release" questions. Use it only to feed compose_view; pass_rate and flaky_by_spec already answer their own questions.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string', description: 'Watch id. Omit for the selected dot, or all dots when none is selected.' },
+                sinceDays: { type: 'integer', description: 'Look back this many days. Default 7 (14 with splitAt), at most 90.' },
+                branch: { type: 'string', description: 'Only runs about this branch: the head branch of a PR check, or the branch a merge went into.' },
+                status: { type: 'string', enum: [...TEST_RESULT_STATUSES], description: 'Only results with this status.' },
+                file: { type: 'string', description: 'Only specs whose path holds this text.' },
+                kind: { type: 'string', enum: [...TEST_RESULT_KINDS], description: 'Only runs of this kind.' },
+                splitAt: { type: 'string', enum: ['last_merge'], description: 'Add a period column: before or after the newest merge into the default branch.' },
+            },
+        },
+    },
+    COMPOSE_VIEW_DEFINITION,
+    {
+        name: 'flaky_by_spec',
+        description: 'Which spec files had tests that passed only on a retry, counted per spec, as a bar chart with the latest runs. The answer shows the chart itself, so write one sentence about it and do not list the numbers. Use it for "flaky tests by spec" or "which specs are flaky".',
+        input_schema: {
+            type: 'object',
+            properties: {
+                dotId: { type: 'string', description: 'Watch id. Omit for the selected dot, or all dots when none is selected.' },
+                sinceDays: { type: 'integer', description: 'Look back this many days. Default 7, at most 90.' },
+            },
+        },
+    },
+]);
+/** Tools that only read. */
+export const READ_ONLY_CHAT_TOOLS = [
+    'list_runs',
+    'get_run',
+    'list_tickets_reviewed',
+    'get_memory',
+    'probe_status',
+    'get_ticket',
+    'pending_approvals',
+    'open_prs',
+    'runs_in_progress',
+    'recent_defects',
+    'pass_rate',
+    'flaky_by_spec',
+    'test_results',
+    'team_status',
+    'release_call',
+    COMPOSE_VIEW_TOOL,
+];
+const PR_URL = /\bhttps?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d{1,9})\b[^\s)>\]]*/gi;
+/** GitHub PR links in a chat line. */
+export function findPrLinks(text) {
+    return [...text.matchAll(PR_URL)].map((m) => ({ owner: m[1], repo: m[2], pr: Number(m[3]), url: m[0] }));
+}
+/** A question about a target ("did you review TAD-3?", "what is TAD-3 about?") reads; it does not start a review. */
+const QUESTION = /^(?:\s*(?:hey|hi|ok|okay)[,!\s]+)?\s*(?:did|do|does|have|has|was|were|is|are|when|why|who|what|which|how|where|show|get|read|summari[sz]e|describe|tell\s+me|explain|open)\b/i;
+const REVIEW_VERB = /\b(?:check|review|re-?review|look\s+(?:at|into|over)|qa|test|analy[sz]e|refine|go\s+through|thoughts|risks?)\b/i;
+/** Text left when the link or key is removed: "check this", "", "?". */
+function residue(text, part) {
+    return text
+        .replace(part, ' ')
+        .replace(/[\s?!.,;:]+/g, ' ')
+        .trim();
+}
+/**
+ * Words that turn a review request into a refusal or a condition: "do not review TAD-3", "review
+ * #12 without commenting", "check it later", "after CI passes". A review always runs now and posts
+ * as the dot rules say, so it cannot honor these; the answer handles them instead.
+ */
+const REVIEW_HOLD = /\b(?:not|dont|never|without|skip|avoid|stop|hold\s+off|wait|later|after|before|once|until|unless|except|tomorrow|tonight)\b|n['\u2019]t\b/i;
+/** Words that ask for test cases to be written: "design tests for TAD-3", "draft test cases". */
+const DESIGN_VERB = /\b(?:design|write|draft|create|generate|add|make)\b[^.?!]*\b(?:tests?|test\s+cases?|cases?)\b/i;
+/** The link and key text out of a chat line, so a word in a Linear slug is not read as a condition. */
+function withoutTargets(text, watch) {
+    let out = text.replace(PR_URL, ' ');
+    for (const t of findTicketRefs(text, watch))
+        out = out.replace(t.url ?? t.key, ' ');
+    return out;
+}
+/**
+ * True when a line that asks to review or check something carries a refusal or a condition
+ * ("don't review TAD-3", "review the PR without commenting", "check it after CI"). The chat then
+ * reads the target or explains the rules, and does not start a review.
+ */
+export function reviewRequestHeld(text, watch) {
+    const rest = withoutTargets(text, watch);
+    return REVIEW_VERB.test(rest) && REVIEW_HOLD.test(rest);
+}
+/**
+ * True when a line that asks to design test cases carries a refusal or a condition ("do not design tests for
+ * TAD-3", "design tests for it later"). design_tests is not offered for that turn.
+ */
+export function designRequestHeld(text, watch) {
+    const rest = withoutTargets(text, watch);
+    return (DESIGN_VERB.test(rest) && REVIEW_HOLD.test(rest)) || reviewRequestHeld(text, watch) || reviewHasConditions(text);
+}
+/**
+ * The tool a chat line asks for by naming a ticket or a PR, called before the model so the answer
+ * starts from the right data. A ticket link with "check" or "review", or a bare link, reviews the
+ * ticket; a question about it reads it. A PR link asks for a review unless it is a question.
+ * Null when the line names neither.
+ */
+export function plannedFirstTool(text, watch) {
+    const tickets = findTicketRefs(text, watch);
+    const prs = findPrLinks(text);
+    if (tickets.length) {
+        const t = tickets[0];
+        const ticket = t.url ?? t.key;
+        const rest = residue(text, ticket);
+        // "design tests for TAD-3" asks for test cases, not a review, unless it carries a refusal or a condition.
+        if (!QUESTION.test(text) && DESIGN_VERB.test(rest) && !designRequestHeld(text, watch)) {
+            const designInput = { ticket };
+            if (watch)
+                designInput.dotId = watch.id;
+            return { name: 'design_tests', input: designInput };
+        }
+        const review = !QUESTION.test(text) && !reviewRequestHeld(text, watch) && (REVIEW_VERB.test(text) || /^(?:this|it|pls|please)?$/i.test(rest));
+        const input = { ticket };
+        if (watch)
+            input.dotId = watch.id;
+        return { name: review ? 'review_ticket' : 'get_ticket', input };
+    }
+    if (prs.length &&
+        !QUESTION.test(text) &&
+        !reviewRequestHeld(text, watch) &&
+        !reviewHasConditions(`review PR ${prs[0].pr}${text.slice(text.indexOf(prs[0].url) + prs[0].url.length)}`)) {
+        const p = prs[0];
+        const input = { pr: p.pr, repo: `${p.owner}/${p.repo}` };
+        if (watch)
+            input.dotId = watch.id;
+        return { name: 'review_pr', input };
+    }
+    return null;
+}
+/** Trailing words a review request may carry and still mean "review it now, as the rules say". */
+const REVIEW_TAIL_OK = /^(?:[\s?!.,;:]|\b(?:please|pls|now|again|thanks|thank\s+you|for\s+me|asap|right\s+away)\b)*$/i;
+/**
+ * A chat line that asks for a review: "review PR 12", "please review #12", "can you review commit
+ * abc1234", "review abc1234..def5678". The line must open with the request, so a question about a
+ * review ("did you review PR 12?") or a refusal ("don't review #12") is not one. Null otherwise.
+ * The rule-based chat and the tool-less CLI backends use it to route the request to review_pr.
+ */
+export function reviewIntent(line) {
+    const r = readReviewRequest(line);
+    return r && !r.conditional ? r.target : null;
+}
+/**
+ * True when the line asks for a review of a target but adds words the review cannot honor
+ * ("review PR 58 without posting a comment", "review #7 after CI passes"). The tool-using chat
+ * hides review_pr for that turn, so the model answers instead of queuing a review that comments.
+ */
+export function reviewHasConditions(line) {
+    return readReviewRequest(line)?.conditional === true;
+}
+function readReviewRequest(line) {
+    // Keywords match in any case; branch names keep theirs, since git refs are case-sensitive.
+    const t = line.trim();
+    const ask = /^(?:(?:hey|hi|ok|okay)[,!\s]+)?(?:please\s+|pls\s+)?(?:(?:can|could|would|will)\s+you\s+(?:please\s+)?|go\s+(?:and\s+)?)?(?:re-?)?review\s+(.+)$/i.exec(t);
+    if (!ask)
+        return null;
+    // The target is the first word after an optional noun: "PR 7", "#7", "commit abc1234", "abc1234..release".
+    const m = /^(?:the\s+)?(?:(pr|pull request|pull)\s*#?\s*|commits?\s+|sha\s+|range\s+)?(\S+)/i.exec(ask[1]);
+    if (!m)
+        return null;
+    // Words after the target may only be politeness. Anything else is a condition the review cannot
+    // honor ("after CI passes", "without posting a comment", "but skip the check"), so the answer
+    // handles it instead. Only the words after the target count, so a branch named
+    // release-after-fix still works.
+    const conditional = !REVIEW_TAIL_OK.test(ask[1].slice(m[0].length));
+    const word = m[2].replace(/[?!,;:]+$/, '').replace(/\.$/, '');
+    if (m[1] || /^#\d/.test(word)) {
+        const n = /^#?(\d{1,9})$/.exec(word);
+        return n ? { target: { pr: Number(n[1]) }, conditional } : null;
+    }
+    const range = /^(.+?)\.{2,3}(.+)$/.exec(word);
+    if (range) {
+        const ref = /^(?!-)(?!.*\.\.)[A-Za-z0-9._/-]{1,200}$/;
+        const sha = (x) => (/^[0-9a-f]{7,40}$/i.test(x) ? x.toLowerCase() : x);
+        return ref.test(range[1]) && ref.test(range[2]) ? { target: { base: sha(range[1]), head: sha(range[2]) }, conditional } : null;
+    }
+    // A bare word must look like a sha (hex with a letter and a digit) unless a noun named it.
+    const hex = word.toLowerCase();
+    if (/^[0-9a-f]{7,40}$/.test(hex) && (/^(commits?|sha)\s/i.test(ask[1].replace(/^the\s+/i, '')) || (/[a-f]/.test(hex) && /\d/.test(hex))))
+        return { target: { sha: hex }, conditional };
+    return null;
+}
+const chatScope = new AsyncLocalStorage();
+/** Requests one chat turn of a lead sends to its members (KAT-405). */
+export const MAX_ROUTED = 3;
+/** Counts one routed request in this turn and returns the count so far. Outside a turn every request is the first. */
+export function bumpRouted() {
+    const s = chatScope.getStore();
+    if (!s)
+        return 1;
+    s.routed = (s.routed ?? 0) + 1;
+    return s.routed;
+}
+/** A view id that is new in this turn. */
+function nextViewId(scope) {
+    return `b-view-${(scope.views = (scope.views ?? 0) + 1)}`;
+}
+/**
+ * For a backend that can see a compose_view call while the model is still writing it: opens the stream that sends the nodes as they
+ * close. Call it where the turn runs, and keep the function it returns for the callbacks of the model's stream, which run apart from
+ * the turn. It gives nothing for a call (nothing is shown) and for a turn with nobody listening.
+ */
+export function viewStreamOpener() {
+    const scope = chatScope.getStore();
+    return () => {
+        if (!scope || !scope.stream || scope.channel === 'call')
+            return undefined;
+        const stream = new ViewStream({
+            results: (scope.results ??= new ResultRegistry()),
+            ...(scope.watch ? { watch: scope.watch } : {}),
+            ...(scope.channel ? { channel: scope.channel } : {}),
+            triage: (window) => buildTriageBlock(scope.watch, window ? { window } : {}),
+            nextId: () => nextViewId(scope),
+            emit: (e) => {
+                try {
+                    scope.emit(e);
+                }
+                catch {
+                    /* the stream closed */
+                }
+            },
+        });
+        (scope.viewStreams ??= []).push(stream);
+        return stream;
+    };
+}
+/** The stream that carried this input, when one did and no call has taken it yet. */
+function claimViewStream(scope, input) {
+    return scope.viewStreams?.find((s) => s.claim(input));
+}
+/** Ends the streams a call did not claim: a view that streamed and has no finished block to replace it is taken away. */
+export function closeViewStreams() {
+    const scope = chatScope.getStore();
+    for (const s of scope?.viewStreams ?? [])
+        s.close();
+    if (scope)
+        scope.viewStreams = [];
+}
+function emitChat(e) {
+    const s = chatScope.getStore();
+    if (!s)
+        return;
+    try {
+        s.emit(e);
+    }
+    catch {
+        /* the stream closed */
+    }
+}
+/** Shows the run card once per turn; the card follows the run's own updates, so it can appear while the run is still going. */
+function emitRunCard(runId) {
+    const s = chatScope.getStore();
+    if (!s)
+        return;
+    const cards = (s.runCards ??= new Set());
+    if (cards.has(runId))
+        return;
+    cards.add(runId);
+    emitChat({ type: 'run', runId });
+}
+/**
+ * Tool definitions for one chat turn: the built-in tools, the dot's MCP tools, and
+ * propose_report_edit when the chat is scoped to a report page.
+ */
+export function chatToolsFor(watch, reportId) {
+    // A lead's chat reads the whole team, routes actions to its members, and has two tools of its own (KAT-405).
+    const tools = watch && isLead(watch) ? leadChatTools(CHAT_TOOLS) : [...CHAT_TOOLS];
+    if (watch)
+        tools.push(...toolsForWatch(watch));
+    if (reportId)
+        tools.push(REPORT_EDIT_TOOL);
+    return tools;
+}
+/**
+ * gate() records every outward action on a run. Chat has no run of its own, so the first gated
+ * action of a turn opens one (trigger kind chat) and the turn finishes it.
+ */
+function archivedNote(watch) {
+    return get('watches', watch.id)?.archived ? `${watch.name} is archived. Restore it to run this.` : undefined;
+}
+function chatRun(watch, title) {
+    const note = archivedNote(watch);
+    if (note)
+        throw new Error(note);
+    const s = chatScope.getStore();
+    if (s?.runId)
+        return s.runId;
+    const run = startRun(watch.id, 'rerun', { source: 'user', kind: 'chat', dedupeKey: `chat:${Date.now().toString(36)}`, title });
+    addStep(run.id, 'Asked in chat', title);
+    if (s)
+        s.runId = run.id;
+    if (s?.origin)
+        recordAsk({ watchId: watch.id, runId: run.id, origin: s.origin });
+    return run.id;
+}
+function approvalFor(runId, match) {
+    return list('approvals', { runId }).find(match);
+}
+/** Job statuses after which the queue will not start the job again. */
+const JOB_SETTLED = new Set(['done', 'failed']);
+/**
+ * Resolves with the run id once the queue starts the run for `jobId`, or undefined when the job
+ * settled without one. It waits on events, not on a clock: a run event ends it at once, and the
+ * job row is re-read at the queue's own tick while nothing has happened. A job queued behind
+ * long runs therefore still gets its card, however long it waits. `maxMs` is a safety valve for a
+ * queue that was stopped, so a chat turn cannot hang forever.
+ */
+export function waitForRunOfJob(askedJobId, maxMs = 5 * 60_000) {
+    // A review that a newer edit of its ticket replaced runs as the newer job: follow it (src/ticket-supersede.ts).
+    const jobOf = () => liveJobId(askedJobId);
+    const find = () => list('runs', { jobId: jobOf() })[0]?.id;
+    const existing = find();
+    if (existing)
+        return Promise.resolve(existing);
+    return new Promise((resolve) => {
+        const done = (id) => {
+            clearTimeout(limit);
+            clearInterval(check);
+            unsub();
+            resolve(id);
+        };
+        const unsub = subscribe((e) => {
+            if (e.type === 'run' && e.run.jobId === jobOf())
+                done(e.run.id);
+        });
+        const check = setInterval(() => {
+            const id = find();
+            if (id)
+                return done(id);
+            const job = get('jobs', jobOf());
+            if (!job || JOB_SETTLED.has(job.status))
+                done(undefined);
+        }, 500);
+        const limit = setTimeout(() => done(undefined), maxMs);
+        check.unref?.();
+        limit.unref?.();
+    });
+}
+/** How long a tool call holds the model's turn for the run id; after that the card still arrives. */
+function runGraceMs() {
+    const n = Number(process.env.LOCALDOST_CHAT_RUN_GRACE_MS);
+    return Number.isFinite(n) && n >= 0 && process.env.LOCALDOST_CHAT_RUN_GRACE_MS ? n : 4000;
+}
+/** Waits for a run to finish, up to timeoutMs. Returns the run as it stands then. */
+function waitForRunDone(runId, timeoutMs) {
+    const now = get('runs', runId);
+    if (!now || now.status !== 'running' || timeoutMs <= 0)
+        return Promise.resolve(now ?? undefined);
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(t);
+            unsub();
+            resolve(get('runs', runId) ?? undefined);
+        };
+        const unsub = subscribe((e) => {
+            if (e.type === 'run' && e.run.id === runId && e.run.status !== 'running')
+                done();
+        });
+        const t = setTimeout(done, timeoutMs);
+        t.unref?.();
+    });
+}
+/** How long review_ticket waits for the review before it answers. LOCALDOST_CHAT_REVIEW_WAIT_SEC, default 150. */
+function reviewWaitMs() {
+    const raw = liveEnv.LOCALDOST_CHAT_REVIEW_WAIT_SEC;
+    const v = raw === undefined || raw === '' ? NaN : Number(raw);
+    return Number.isFinite(v) && v >= 0 ? v * 1000 : 150_000;
+}
+function clip(text, max = 160) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 3)}...` : one;
+}
+/** True when a tool's value is a failure: an error text, or a refusal with a message. */
+export function toolFailed(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const v = value;
+    return typeof v.error === 'string' || (typeof v.message === 'string' && (v.ok === false || v.status === 'error'));
+}
+/** One line for the tool line in chat. */
+export function summarizeToolResult(name, value) {
+    if (!value || typeof value !== 'object')
+        return clip(String(value ?? 'Done'));
+    const v = value;
+    if (typeof v.error === 'string')
+        return clip(v.error);
+    if (typeof v.message === 'string' && v.ok === false)
+        return clip(v.message);
+    // A request a lead sent to a member says who got it and what it was asked: "Asked PR Reviewer to check PR #12 again" (KAT-405).
+    if (typeof v.routedTo === 'string' && typeof v.ask === 'string')
+        return clip(`Asked ${v.routedTo} to ${v.ask}`);
+    switch (name) {
+        case 'team_status':
+            return clip(`${String(v.status ?? 'Team')}: ${String(v.reason ?? '')}`);
+        case 'release_call':
+            return clip(`${String(v.answer ?? 'Release')}: ${String(v.summary ?? '')}`);
+        case 'list_runs':
+            return `${Number(v.count ?? 0)} runs`;
+        case 'get_run':
+            return clip(String(v.headline ?? v.trigger ?? v.status ?? 'Run loaded'));
+        case 'rerun_tests':
+            return v.queued ? `Queued a run for ${String(v.dot ?? 'the dot')}` : clip(String(v.reason ?? 'Nothing queued'));
+        case 'review_pr':
+            return v.duplicate
+                ? clip(`Already reviewing: ${String(v.title ?? '')}`)
+                : v.queued
+                    ? clip(`Queued a review: ${String(v.title ?? '')}`)
+                    : 'Nothing queued';
+        case 'add_memory':
+            return v.saved ? 'Saved to memory' : 'Not saved';
+        case 'get_ticket':
+            return clip(`${String(v.key ?? '')}: ${String(v.title ?? '')}`);
+        case 'review_ticket':
+            return v.duplicate
+                ? clip(`Already reviewing: ${String(v.title ?? '')}`)
+                : v.status === 'running' || v.status === 'queued'
+                    ? clip(`Reviewing: ${String(v.title ?? '')}`)
+                    : clip(String(v.headline ?? v.title ?? 'Review queued'));
+        case 'design_tests':
+            return v.duplicate
+                ? clip(`Already designing: ${String(v.title ?? '')}`)
+                : v.status === 'running' || v.status === 'queued'
+                    ? clip(`Designing: ${String(v.title ?? '')}`)
+                    : `${Number(v.count ?? 0)} ${Number(v.count ?? 0) === 1 ? 'case' : 'cases'} for ${String(v.ticket ?? 'the ticket')}`;
+        case 'pending_approvals':
+            return `${Number(v.count ?? 0)} waiting`;
+        case 'open_prs':
+            return `${Number(v.count ?? 0)} open`;
+        case 'runs_in_progress':
+            return `${Number(v.count ?? 0)} running, ${Number(v.queuedCount ?? 0)} queued`;
+        case 'recent_defects':
+            return `${Number(v.count ?? 0)} found`;
+        case 'list_cases':
+            return `${Number(v.count ?? 0)} ${Number(v.count ?? 0) === 1 ? 'case' : 'cases'}`;
+        case 'pass_rate':
+            return typeof v.passRatePercent === 'number' ? `${v.passRatePercent}% passed` : clip(String(v.note ?? 'No test runs'));
+        case 'flaky_by_spec':
+            return Number(v.specs ?? 0) > 0 ? `${Number(v.specs)} flaky specs` : clip(String(v.note ?? 'No flaky tests'));
+        case 'test_results':
+            return Number(v.count ?? 0) > 0 ? `${Number(v.count)} test results` : clip(String(v.note ?? 'No test results'));
+        case COMPOSE_VIEW_TOOL:
+            return Array.isArray(v.shown) && v.shown.length ? `Showed ${v.shown.join(', ')}` : clip(String(v.note ?? 'No view'));
+        case 'probe_status': {
+            const probes = Array.isArray(v.probes) ? v.probes : [];
+            return probes.length ? `${probes.length} probe${probes.length === 1 ? '' : 's'}` : clip(String(v.note ?? 'No probes'));
+        }
+        case 'propose_report_edit':
+            return v.status === 'executed'
+                ? 'Edit saved'
+                : v.status === 'pending_approval'
+                    ? 'Edit waits for your approval'
+                    : clip(String(v.message ?? v.status ?? ''));
+    }
+    if (Array.isArray(value))
+        return `${value.length} item${value.length === 1 ? '' : 's'}`;
+    if (isMcpToolName(name)) {
+        const result = v.result;
+        if (typeof result?.text === 'string' && result.text)
+            return clip(result.text);
+        return clip(String(v.message ?? v.status ?? 'Done'));
+    }
+    return clip(JSON.stringify(value));
+}
+async function runMcpTool(name, input, ctx) {
+    const watch = ctx.watch;
+    if (!watch)
+        return { ok: false, status: 'error', tool: name, message: 'Pick a dot first; MCP tools belong to a dot.' };
+    const binding = bindingsFor(watch).get(name);
+    const archived = binding && !binding.tool.readOnly ? archivedNote(watch) : undefined;
+    if (archived)
+        return { ok: false, status: 'error', tool: name, message: archived };
+    // Read-only tools need no run; anything else is gated and recorded on the chat run.
+    const runId = binding && !binding.tool.readOnly ? chatRun(watch, `Run ${binding.tool.name} on ${binding.conn.name}`) : '';
+    const outcome = await callConnectionTool(watch, name, input, runId);
+    if (outcome.approvalId) {
+        const approval = get('approvals', outcome.approvalId);
+        if (approval)
+            emitChat({ type: 'approval', approval });
+    }
+    return outcome;
+}
+async function proposeReportEdit(input, ctx) {
+    const reportId = ctx.reportId;
+    if (!reportId)
+        return { error: 'No report page is open in this chat.' };
+    const page = getReport(reportId);
+    if (!page)
+        return { error: 'That report page no longer exists.' };
+    const markdown = typeof input.markdown === 'string' ? input.markdown : '';
+    if (!markdown.trim())
+        return { error: 'markdown is required: send the full new page.' };
+    const watch = (page.watchId ? get('watches', page.watchId) : undefined) ?? ctx.watch;
+    if (!watch)
+        return { error: 'This page belongs to no dot, so nobody can approve an edit.' };
+    const archived = archivedNote(watch);
+    if (archived)
+        return { error: archived };
+    // KAT-399: a copy of the Team notes in the model's page is cut before the card shows the diff and before the page is saved.
+    const edit = scrubReportEdit(watch, { markdown, note: str(input.note), title: str(input.title) });
+    if (!edit)
+        return { error: 'The page you wrote only repeats the Team notes. Write the page again in your own words.' };
+    const action = proposeReportEditAction({ reportId, markdown: edit.markdown, note: edit.note, title: edit.title });
+    action.meta = { ...action.meta, askedBy: 'user' };
+    const runId = chatRun(watch, `Edit report "${page.title}"`);
+    const status = await gate(action, watch, runId);
+    const approval = approvalFor(runId, (a) => a.action.kind === 'report_edit' && a.action.meta?.reportId === reportId && a.status === 'pending');
+    if (approval && status === 'pending_approval')
+        emitChat({ type: 'approval', approval });
+    return { status, reportId, ...(approval ? { approvalId: approval.id } : {}) };
+}
+function str(v) {
+    return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+function resolveWatch(input, ctx) {
+    const id = str(input.dotId);
+    if (id)
+        return get('watches', id) ?? undefined;
+    if (ctx.watch)
+        return ctx.watch;
+    const all = list('watches').filter((w) => !w.archived);
+    return all.length === 1 ? all[0] : undefined;
+}
+function minutesSince(iso) {
+    return Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 60000));
+}
+/**
+ * A run that found something a person should look at: a failed outcome, or a high risk. A run that broke on
+ * infrastructure (a crashed job, an environment failure) is not a defect in the product or its tests (KAT-158).
+ */
+function isDefectRun(r) {
+    const o = r.verdict?.outcome;
+    if (o === 'product_failure' || o === 'test_failure' || o === 'flaky')
+        return true;
+    if (o === 'environment_failure')
+        return false;
+    return (r.verdict?.findings ?? []).some((f) => f.severity === 'high') && o !== 'pass' && o !== 'info';
+}
+function newestFirst(rows) {
+    return [...rows].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export function summarizeRun(r) {
+    return {
+        runId: r.id,
+        dotId: r.watchId,
+        kind: r.kind,
+        status: r.status,
+        at: r.createdAt,
+        trigger: r.trigger?.title ?? null,
+        outcome: r.verdict?.outcome ?? null,
+        headline: r.verdict?.headline ?? null,
+        tests: r.report ? { passed: r.report.passed, failed: r.report.failed, flaky: r.report.flaky } : null,
+        pendingApprovals: (r.actions ?? []).filter((a) => a.result === 'pending_approval').length,
+    };
+}
+/** Same call key for the same tool and input; dotId of the selected dot counts as no dotId. */
+function callKey(name, input, ctx) {
+    const o = { ...(input && typeof input === 'object' ? input : {}) };
+    if (ctx.watch && o.dotId === ctx.watch.id)
+        delete o.dotId;
+    const sorted = Object.keys(o)
+        .sort()
+        .map((k) => [k, o[k]]);
+    return `${name}:${JSON.stringify(sorted)}`;
+}
+/** True when this turn already called the tool with the same input. */
+export function isRepeatChatCall(name, input, ctx) {
+    return chatScope.getStore()?.calls?.has(callKey(name, input, ctx)) === true;
+}
+/**
+ * Runs a tool for a backend: a repeat of a call made this turn, finished or still running, returns the
+ * first result with a note and shows no second card; anything else shows the card and runs the tool.
+ * The call is recorded before it runs, so sibling calls that start together cannot both execute.
+ */
+export async function callChatTool(name, input, ctx, onTool) {
+    const scope = chatScope.getStore();
+    const key = callKey(name, input, ctx);
+    const prev = scope?.calls?.get(key);
+    if (prev !== undefined)
+        return { repeated: true, note: 'This exact call already ran this turn; use the result you have. Do not call it again.', result: await prev };
+    onTool(name, input);
+    const running = executeChatTool(name, input, ctx);
+    if (scope) {
+        (scope.calls ??= new Map()).set(key, running);
+        // A call that threw is not a result to repeat; a later identical call runs again.
+        running.catch(() => scope.calls?.get(key) === running && scope.calls.delete(key));
+    }
+    return running;
+}
+let toolStub;
+export function setChatToolStub(fn) {
+    toolStub = fn;
+}
+/** Runs one chat tool and streams a one-line result to the chat when a turn is in progress. */
+export async function executeChatTool(name, rawInput, ctx) {
+    let dispatched;
+    try {
+        dispatched = await dispatchChatTool(name, rawInput, ctx);
+    }
+    catch (err) {
+        // The chat shows the failed call as one line with the reason; the backend still gets the error.
+        emitChat({ type: 'tool_result', name, summary: clip(err instanceof Error ? err.message : String(err)), error: true });
+        throw err;
+    }
+    // A tool that answers with blocks hands them over in `blocks`; the model only sees the numbers.
+    const { value, blocks: attached } = splitBlocks(dispatched);
+    // A lookup result gets an id for the turn, so a composed view can read it (KAT-366). The model reads the id with the result.
+    const turn = chatScope.getStore();
+    if (turn && VIEW_SOURCE_TOOLS.includes(name) && value && typeof value === 'object' && !toolFailed(value)) {
+        // Only the chat's own dot feeds a view: a lookup for another dot gets no id, and the model reads why.
+        const own = turn.watch ?? ctx.watch;
+        const rawObj = (rawInput && typeof rawInput === 'object' ? rawInput : {});
+        const foreign = foreignDotOf(rawObj, own);
+        if (foreign && own)
+            refuseResult(value, foreignSourceLine(foreign, own));
+        else {
+            const entry = (turn.results ??= new ResultRegistry()).add(name, (rawInput && typeof rawInput === 'object' ? rawInput : {}), value, attached);
+            tagResult(value, entry.id);
+        }
+    }
+    // The lookup tools answer with their rows, and the matching block is built from that result, so a stubbed tool
+    // (the chat eval) shows the same block as the real one. A call marked `context` shows none (docs/CHAT-UI.md).
+    const blocks = chatScope.getStore()?.channel === 'call' ? [] : attached.length ? attached : lookupBlocks(name, value, rawInput, ctx);
+    emitChat({ type: 'tool_result', name, summary: summarizeToolResult(name, value), ...(toolFailed(value) ? { error: true } : {}) });
+    // The result of queued work replies where it was asked (KAT-143).
+    const origin = chatScope.getStore()?.origin;
+    const jobId = value && typeof value === 'object' ? value.jobId : undefined;
+    if (origin && typeof jobId === 'string')
+        recordAskForJob(jobId, origin);
+    for (const b of blocks)
+        emitBlock({ ...b, tool: name });
+    if (name === 'design_tests' && value && typeof value === 'object' && typeof value.runId === 'string')
+        emitRunCard(value.runId);
+    if (name === 'review_ticket' && value && typeof value === 'object' && typeof value.runId === 'string') {
+        emitRunCard(value.runId);
+        const designed = value.testCases;
+        const scope = chatScope.getStore();
+        if (designed && scope)
+            (scope.lines ??= []).push(designedChatLine(designed));
+        const approvalId = value.approvalId;
+        const approval = typeof approvalId === 'string' ? get('approvals', approvalId) : undefined;
+        if (approval)
+            emitChat({ type: 'approval', approval });
+    }
+    // A design run that already has its card (runId) needs no late one; a queued one gets its card when it starts.
+    const queuedDesign = name === 'design_tests' && value && typeof value === 'object' && typeof value.runId !== 'string';
+    if ((name === 'rerun_tests' || name === 'review_pr' || queuedDesign) &&
+        value &&
+        typeof value === 'object' &&
+        typeof value.jobId === 'string') {
+        const scope = chatScope.getStore();
+        const wait = waitForRunOfJob(value.jobId);
+        const emitRun = (runId) => {
+            if (runId)
+                emitRunCard(runId);
+        };
+        // Fast path: the model learns the run id when the queue starts the job right away.
+        let graceTimer;
+        const grace = new Promise((resolve) => {
+            graceTimer = setTimeout(() => resolve('late'), runGraceMs());
+            graceTimer.unref?.();
+        });
+        const first = await Promise.race([wait, grace]).finally(() => clearTimeout(graceTimer));
+        if (first !== 'late') {
+            if (first)
+                value.runId = first;
+            emitRun(first);
+        }
+        else if (scope?.stream) {
+            // The job waits behind other runs. The model answers now; the turn's stream stays open until
+            // the card is sent (runChat awaits `pending`), so a busy queue never hides it.
+            scope.pending.push(wait.then(emitRun));
+        }
+    }
+    return value;
+}
+/** The test designer's part of a review_ticket result: the count, the line, and the filtered Test cases link (KAT-164). */
+export function designedChat(dotId, d) {
+    return {
+        designed: d.added,
+        alreadyThere: d.existing,
+        line: designedLine(d),
+        link: designedCasesHref(dotId, d),
+        note: 'localdost adds this line with its link at the end of the answer. Do not repeat it.',
+    };
+}
+/** The chat line for designed cases, with its link: "3 test cases designed. [Open the test cases](#/cases?...)". */
+export function designedChatLine(t) {
+    return `${t.line}. [Open the test cases](${t.link})`;
+}
+const BLOCKS_KEY = '__blocks';
+/** A tool result paired with the blocks it carries. Used only between a tool and executeChatTool. */
+export function withBlocks(result, extra) {
+    const out = { ...extra, ...result.facts };
+    Object.defineProperty(out, BLOCKS_KEY, { value: result.blocks, enumerable: false });
+    return out;
+}
+export function splitBlocks(value) {
+    const blocks = value && typeof value === 'object' ? value[BLOCKS_KEY] : undefined;
+    return { value, blocks: Array.isArray(blocks) ? blocks : [] };
+}
+/**
+ * Words that ask about the dot's own review of a ticket: that it ran, what it found, what it asked, the comment it
+ * drafted. "comment" alone is not one: "the latest comment on TAD-3 in Jira" asks about the tracker.
+ */
+const TICKET_REVIEW_WORDS = /\b(?:review(?:ed|s)?|risks?|open\s+questions?|test\s+ideas?|findings?|(?:your|drafted?|review)\s+comments?|comments?\s+(?:did\s+)?you|you\s+(?:comment(?:ed)?|post(?:ed)?|draft(?:ed)?))\b/i;
+/** A request for a new review, not a question about the stored one: "review TAD-3 again", "please review TAD-3". */
+const REVIEW_REQUEST = /^\s*(?:(?:hey|hi|ok|okay)[,!\s]+)?(?:(?:please|pls|just|can\s+you|could\s+you|would\s+you|will\s+you)\s+)*(?:re-?review|review|re-?check|check)\b/i;
+/** A risk in general, not a risk the review found: "the risks of shipping TAD-3". */
+const GENERAL_RISK = /\brisks?\s+(?:of|in|with|around)\s+(?:shipping|releasing|deploying|merging|launching|rolling)\b/gi;
+/**
+ * True when the person asks about the review the dot wrote for a ticket. get_ticket then shows that review as a
+ * block, unless the model marked the call `context`; a plain "what is TAD-3 about?" reads the ticket and shows
+ * none. A refusal or a condition ("do not review TAD-3"), a request for a new review ("review TAD-3 again"),
+ * and a question about the tracker or about shipping the ticket are not questions about the stored review.
+ */
+export function asksAboutTicketReview(question, watch) {
+    if (!question)
+        return false;
+    const rest = withoutTargets(question, watch);
+    if (REVIEW_REQUEST.test(rest) || reviewRequestHeld(question, watch))
+        return false;
+    return TICKET_REVIEW_WORDS.test(rest.replace(GENERAL_RISK, ' '));
+}
+/** Blocks for the result of a lookup tool; none when the call is a context lookup, failed, or has no rows. */
+function lookupBlocks(name, value, rawInput, ctx) {
+    const input = (rawInput && typeof rawInput === 'object' ? rawInput : {});
+    const dot = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+    const question = chatScope.getStore()?.question;
+    return blocksFromToolResult(name, value, input, {
+        ...(dot ? { dot } : {}),
+        ...(name === 'get_ticket' ? { showTicketReview: asksAboutTicketReview(question, dot ?? ctx.watch) } : {}),
+    });
+}
+/** Checks a block, streams it, and keeps it for the stored reply. A block that fails the check is dropped; the text still answers. */
+function emitBlock(raw, opts = {}) {
+    const parsed = parseChatBlock(raw);
+    if (!parsed.ok)
+        return undefined;
+    const scope = chatScope.getStore();
+    if (scope)
+        (scope.blocks ??= new Map()).set(parsed.block.id, parsed.block);
+    if (!opts.quiet)
+        emitChat({ type: 'block', block: parsed.block });
+    return parsed.block;
+}
+/**
+ * The objects whose card the client draws under the person's message: the links it unfurls, which are the first three distinct
+ * PR, issue, Jira, and Linear addresses (src/object-links.ts, the same function the client calls). A link past the third, or an
+ * address the client does not unfurl, is not in this set, so the answer still gets its card.
+ */
+function unfurledKeys(userText) {
+    return new Set(objectLinksIn(userText ?? '').map((l) => l.key));
+}
+/**
+ * Streams the object cards of a tool call as one block. A link the person pasted unfurls into a card under their own message,
+ * so a card for the same object is left out here; every other object the dot reads or acts on gets a card in the answer (KAT-136).
+ */
+function emitCards(cards, tool) {
+    const pasted = unfurledKeys(chatScope.getStore()?.userText);
+    const fresh = cards.filter((c) => !pasted.has(refKey(objectOfCard(c))));
+    if (fresh.length)
+        emitBlock({ id: `b-card-${fresh.map((c) => c.ref).join('-')}`, kind: 'cards', cards: fresh, tool });
+}
+/** Builds the PR card after the tool answered, so GitHub's reads never hold the model. It lands in the answer when it is ready. */
+function cardLater(build, tool) {
+    const scope = chatScope.getStore();
+    if (!scope?.stream)
+        return;
+    scope.pending.push(build()
+        .then((card) => {
+        if (!card)
+            return;
+        const pasted = unfurledKeys(scope.userText);
+        if (pasted.has(refKey(objectOfCard(card))))
+            return;
+        emitBlock({ id: `b-card-${card.ref}`, kind: 'cards', cards: [card], tool });
+    })
+        .catch(() => undefined));
+}
+/**
+ * The answer of test_results for a list of runs: the model reads the columns, the count, and a sample, and the full rows are held for
+ * compose_view under the result id. The chat eval answers the tool from fixed runs through this same function (src/cli/eval-chat.ts).
+ */
+export function testResultsAnswer(input, runs, scope, names, now) {
+    const status = str(input.status);
+    const kind = str(input.kind);
+    if (status && !TEST_RESULT_STATUSES.includes(status))
+        return { error: `status must be one of ${TEST_RESULT_STATUSES.join(', ')}.` };
+    if (kind && !TEST_RESULT_KINDS.includes(kind))
+        return { error: `kind must be one of ${TEST_RESULT_KINDS.join(', ')}.` };
+    if (input.splitAt !== undefined && input.splitAt !== 'last_merge')
+        return { error: 'splitAt must be last_merge.' };
+    const days = typeof input.sinceDays === 'number' && Number.isFinite(input.sinceDays) ? input.sinceDays : undefined;
+    const res = testResultRows(runs, {
+        ...(now !== undefined ? { now } : {}),
+        ...(days !== undefined ? { sinceDays: days } : {}),
+        ...(str(input.branch) ? { branch: str(input.branch) } : {}),
+        ...(status ? { status } : {}),
+        ...(str(input.file) ? { file: str(input.file) } : {}),
+        ...(kind ? { kind } : {}),
+        ...(input.splitAt === 'last_merge' ? { splitAt: 'last_merge' } : {}),
+        dotName: (id) => names.get(id),
+    });
+    return holdRows({
+        scope,
+        window: res.window,
+        ...rowsSummary(res.table, res.total),
+        ...(res.table.more ? { more: res.table.more } : {}),
+        ...(res.split ? { split: res.split } : {}),
+        ...(res.note ? { note: res.note } : { note: 'The rows are held for compose_view. Read them there with this resultId.' }),
+    }, res.table);
+}
+/**
+ * The open pull requests of the app repos of these dots, read from GitHub, one call per repo. A repo two dots share is read once. With
+ * `maxRepos` (a lead's chat reads many dots, KAT-405) the rest are skipped and the result says how many.
+ */
+export async function readOpenPrs(dots, limit, o = {}) {
+    if (!dots.length)
+        return { count: 0, prs: [], note: 'No dot with a repo to read pull requests from.' };
+    const seen = new Set();
+    const prs = [];
+    const errors = [];
+    let skipped = 0;
+    let read = 0;
+    for (const w of dots) {
+        // Every app repo of the dot, not only the first: `repo` on the dot mirrors just that one.
+        for (const r of watchRepos(w).filter((x) => x.role === 'app')) {
+            const full = `${r.owner}/${r.name}`;
+            if (seen.has(full.toLowerCase()))
+                continue;
+            seen.add(full.toLowerCase());
+            if (o.maxRepos !== undefined && read >= o.maxRepos) {
+                skipped++;
+                continue;
+            }
+            read++;
+            try {
+                const rows = (await githubFor(w, { repo: { owner: r.owner, name: r.name } }).listPulls(50)).filter((p) => p.state === 'open').slice(0, limit);
+                for (const p of rows) {
+                    prs.push({
+                        dotId: w.id,
+                        repo: full,
+                        number: p.number,
+                        title: p.title,
+                        author: p.author ?? null,
+                        url: p.url ?? null,
+                        updatedAt: p.updatedAt ?? null,
+                    });
+                }
+            }
+            catch (err) {
+                errors.push(`${full}: ${err instanceof Error ? err.message : String(err)}`.slice(0, 200));
+            }
+        }
+    }
+    return {
+        count: prs.length,
+        prs,
+        ...(errors.length ? { errors } : {}),
+        ...(skipped ? { skipped, note: `Skipped ${skipped} ${skipped === 1 ? 'repo' : 'repos'}. Ask about one dot to see them.` } : {}),
+        ...(prs.length || errors.length || skipped ? {} : { note: 'No open pull requests.' }),
+    };
+}
+async function dispatchChatTool(name, rawInput, ctx) {
+    const input = (rawInput && typeof rawInput === 'object' ? rawInput : {});
+    // compose_view only arranges what the lookups returned, so a stubbed eval still runs the real one.
+    if (toolStub && name !== COMPOSE_VIEW_TOOL)
+        return toolStub(name, input, ctx);
+    if (isMcpToolName(name))
+        return runMcpTool(name, rawInput, ctx);
+    // A Lead QA dot (KAT-405) answers from all its members and routes an action to the member whose job it is.
+    if (ctx.watch && isLead(ctx.watch) && !ctx.member) {
+        const led = await dispatchLeadTool(name, input, { ...ctx, team: ctx.team ?? membersOf(ctx.watch) }, { run: dispatchChatTool });
+        if (led !== undefined)
+            return led;
+    }
+    switch (name) {
+        case 'get_ticket': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const parsed = parseTicketInput(input.ticket, watch);
+            if (!parsed.ok)
+                return { error: parsed.error };
+            const res = await fetchTicketRef(watch, parsed.ref);
+            if (!res.ok)
+                return { error: res.error };
+            const t = res.ticket;
+            const last = newestFirst(list('runs', { watchId: watch.id, kind: 'ticket_review' })).find((r) => r.trigger?.ticket?.key === t.key && r.trigger.ticket.tracker === t.tracker);
+            const cut = (x, n) => (x && x.length > n ? `${x.slice(0, n)} [truncated]` : (x ?? null));
+            const card = ticketToCard(t, watch);
+            emitCards([card], 'get_ticket');
+            // A composed view may show the card too, even when the person pasted the link and it already unfurled (KAT-366).
+            return holdViewBlocks({
+                key: t.key,
+                tracker: t.tracker,
+                title: t.title,
+                type: t.type ?? null,
+                priority: t.priority ?? null,
+                labels: t.labels ?? [],
+                reporter: t.reporter ?? null,
+                url: t.url ?? null,
+                description: cut(t.description, 2500),
+                acceptanceCriteria: cut(t.acceptanceCriteria, 1500),
+                lastReview: last
+                    ? {
+                        runId: last.id,
+                        at: last.createdAt,
+                        headline: last.verdict?.headline ?? null,
+                        commentStatus: last.actions.find((a) => a.action.kind === 'ticket_comment')?.result ?? 'none',
+                    }
+                    : null,
+                status: t.status ?? null,
+                assignee: t.assignee ?? null,
+            }, [{ id: `b-card-${card.ref}`, kind: 'cards', cards: [card], tool: 'get_ticket' }]);
+        }
+        case 'review_ticket': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const parsed = parseTicketInput(input.ticket, watch);
+            if (!parsed.ok)
+                return { error: parsed.error };
+            const res = await requestTicketReview(watch, parsed.ref, { requestedBy: 'chat' });
+            if (!res.ok)
+                return { error: res.error };
+            const base = { queued: !res.duplicate, duplicate: res.duplicate, jobId: res.jobId, title: res.title, ticket: res.ticket.key, dot: watch.name };
+            emitCards([ticketToCard(res.ticket, watch)], 'review_ticket');
+            const runId = await waitForRunOfJob(res.jobId, 4000);
+            if (!runId)
+                return { ...base, status: 'queued', note: 'The review is queued behind other work; its result lands in the run list.' };
+            // The card shows as soon as the run starts and follows the run to its end, however long the wait below is.
+            emitRunCard(runId);
+            const run = await waitForRunDone(runId, reviewWaitMs());
+            if (!run || run.status === 'running')
+                return { ...base, runId, status: 'running', note: 'The review is still running; the run card updates when it finishes.' };
+            const comment = run.actions.find((a) => a.action.kind === 'ticket_comment');
+            const approval = approvalFor(runId, (a) => a.action.kind === 'ticket_comment' && a.status === 'pending');
+            return {
+                ...base,
+                runId,
+                status: run.status,
+                outcome: run.verdict?.outcome ?? null,
+                headline: run.verdict?.headline ?? null,
+                risks: (run.verdict?.findings ?? []).slice(0, 5).map((f) => `${f.severity}: ${f.title}`),
+                openQuestions: (run.verdict?.openQuestions ?? []).slice(0, 5),
+                testIdeas: (run.verdict?.testIdeas ?? []).slice(0, 3),
+                ...(run.designed && !run.designed.error ? { testCases: designedChat(watch.id, run.designed) } : {}),
+                comment: comment?.result ?? 'none',
+                ...(approval ? { approvalId: approval.id } : {}),
+                ...(run.status === 'failed' ? { error: run.steps.at(-1)?.detail ?? 'The review failed.' } : {}),
+            };
+        }
+        case 'design_tests': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const parsed = parseTicketInput(input.ticket, watch);
+            if (!parsed.ok)
+                return { error: parsed.error };
+            const res = await requestTestDesign(watch, parsed.ref, { requestedBy: 'chat' });
+            if (!res.ok)
+                return { error: res.error };
+            const base = { queued: !res.duplicate, duplicate: res.duplicate, jobId: res.jobId, title: res.title, ticket: res.ticket.key, dot: watch.name };
+            const runId = await waitForRunOfJob(res.jobId, runGraceMs());
+            if (!runId)
+                return {
+                    ...base,
+                    status: 'queued',
+                    note: 'The test design is queued behind other work; its run card shows in this chat when the run starts, and the run list has it too.',
+                };
+            emitRunCard(runId);
+            const run = await waitForRunDone(runId, reviewWaitMs());
+            if (!run || run.status === 'running')
+                return { ...base, runId, status: 'running', note: 'The test design is still running; the run card updates when it finishes.' };
+            if (run.status === 'failed' || run.designed?.error || !run.designed)
+                return { ...base, runId, status: run.status, error: run.designed?.error ?? run.steps.at(-1)?.detail ?? 'The test design failed.' };
+            const designed = run.designed;
+            const cases = casesForTicket(teamIds(watch.id), designed.requirement);
+            const block = casesBlock(watch, { requirement: designed.requirement, status: 'all' });
+            return withBlocks({
+                blocks: [
+                    { ...block, id: `b-design-${watch.id}-${designed.requirement}`, title: `Designed test cases for ${designed.requirement}`, tool: 'design_tests' },
+                ],
+                facts: {
+                    runId,
+                    status: run.status,
+                    count: cases.length,
+                    designed: designed.added,
+                    alreadyThere: designed.existing,
+                    line: designedLine(designed),
+                    link: designedCasesHref(watch.id, designed),
+                    cases: cases.slice(0, 30).map((c) => ({ key: c.key, title: c.title, status: c.status })),
+                    note: 'The card lists the cases with their keys and status. Do not repeat the rows.',
+                },
+            }, base);
+        }
+        case 'list_approvals':
+        case 'pending_approvals': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const limit = typeof input.limit === 'number' ? Math.min(20, input.limit) : 10;
+            const rows = [...list('approvals', watch ? { watchId: watch.id, status: 'pending' } : { status: 'pending' })].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            return {
+                count: rows.length,
+                approvals: rows.slice(0, limit).map((a) => ({
+                    approvalId: a.id,
+                    dotId: a.watchId,
+                    runId: a.runId,
+                    kind: a.action.kind,
+                    target: a.action.target,
+                    title: a.action.title,
+                    reason: a.reason,
+                    at: a.createdAt,
+                    waitingMinutes: minutesSince(a.createdAt),
+                })),
+            };
+        }
+        case 'open_prs': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const limit = typeof input.limit === 'number' ? Math.max(1, Math.min(30, input.limit)) : 10;
+            return readOpenPrs((watch ? [watch] : list('watches')).filter((w) => !w.paused && hasAppRepo(w)), limit);
+        }
+        case 'runs_in_progress': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const scope = watch ? { watchId: watch.id } : {};
+            const running = newestFirst(list('runs', { ...scope, status: 'running' }));
+            const queued = list('jobs', {
+                ...scope,
+                status: 'queued',
+            });
+            return {
+                count: running.length,
+                runs: running.slice(0, 20).map((r) => ({ ...summarizeRun(r), runningMinutes: minutesSince(r.createdAt) })),
+                queuedCount: queued.length,
+                queued: queued
+                    .slice(0, 20)
+                    .map((j) => ({ kind: j.kind, dotId: j.watchId, title: j.payload?.title ?? null, waitingMinutes: minutesSince(j.createdAt) })),
+            };
+        }
+        case 'recent_defects': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const limit = typeof input.limit === 'number' ? Math.max(1, Math.min(20, input.limit)) : 8;
+            const all = newestFirst(watch ? list('runs', { watchId: watch.id }) : list('runs'));
+            let since;
+            if (input.sinceLastMerge === true) {
+                since = all.find((r) => r.kind === 'post_merge')?.createdAt ?? new Date(Date.now() - 168 * 3600_000).toISOString();
+            }
+            else {
+                const hours = typeof input.sinceHours === 'number' && Number.isFinite(input.sinceHours) ? Math.max(1, Math.min(24 * 90, input.sinceHours)) : 168;
+                since = new Date(Date.now() - hours * 3600_000).toISOString();
+            }
+            const bad = all.filter((r) => r.createdAt >= since && (isDefectRun(r) || (r.status === 'failed' && !r.verdict && (r.report?.failed ?? 0) > 0)));
+            return {
+                count: bad.length,
+                since,
+                defects: bad.slice(0, limit).map((r) => ({
+                    ...summarizeRun(r),
+                    failingTests: (r.report?.cases ?? [])
+                        .filter((c) => c.status === 'failed' || c.status === 'timedOut')
+                        .slice(0, 5)
+                        .map((c) => ({ title: c.title, file: c.file, error: c.error?.replace(/\u001b\[[0-9;]*m/g, '').slice(0, 200) })),
+                    risks: (r.verdict?.findings ?? [])
+                        .filter((f) => f.severity === 'high')
+                        .slice(0, 3)
+                        .map((f) => f.title),
+                    suspectedCause: r.verdict?.suspectedCause ?? null,
+                })),
+            };
+        }
+        case 'propose_report_edit':
+            return proposeReportEdit(input, ctx);
+        case 'list_cases': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const filters = { status: str(input.status), kind: str(input.kind), requirement: str(input.requirement) };
+            try {
+                const { cases } = listCases(watch, filters);
+                // The block goes out through executeChatTool -> emitBlock, like the stats blocks, so it keeps its id in the turn's block map.
+                return withBlocks({
+                    blocks: [casesBlock(watch, filters)],
+                    facts: {
+                        count: cases.length,
+                        cases: cases.slice(0, 30).map((c) => ({
+                            key: c.key,
+                            title: c.title,
+                            kind: c.kind,
+                            priority: c.priority,
+                            status: c.status,
+                            requirements: c.requirementRefs,
+                            specPath: c.specPath ?? null,
+                            latest: c.latest ? { result: c.latest.result, at: c.latest.at, runId: c.latest.runId ?? null } : null,
+                        })),
+                        ...(cases.length ? {} : { note: 'No test cases match. Add them on the Test cases page.' }),
+                    },
+                }, {});
+            }
+            catch (err) {
+                if (err instanceof CaseInputError)
+                    return { error: err.message };
+                throw err;
+            }
+        }
+        case 'test_results': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const runs = watch ? list('runs', { watchId: watch.id }) : list('runs');
+            return testResultsAnswer(input, runs, watch?.name ?? 'all dots', new Map(list('watches').map((w) => [w.id, w.name])));
+        }
+        case COMPOSE_VIEW_TOOL: {
+            const scope = chatScope.getStore();
+            if (!scope)
+                return { error: 'No chat turn is open, so there is nowhere to show a view.' };
+            // The nodes of this call may already be on the client: the stream that read them while the model wrote it carries on.
+            const stream = claimViewStream(scope, rawInput);
+            return composeView(rawInput, {
+                results: (scope.results ??= new ResultRegistry()),
+                ...((scope.watch ?? ctx.watch) ? { watch: (scope.watch ?? ctx.watch) } : {}),
+                ...(scope.channel ? { channel: scope.channel } : {}),
+                ...(scope.messageId ? { messageId: scope.messageId } : {}),
+                triage: (window) => buildTriageBlock(scope.watch ?? ctx.watch, window ? { window } : {}),
+                nextId: () => nextViewId(scope),
+                emit: (e) => emitChat(e),
+                finish: (block, o) => emitBlock(block, o),
+                hide: (ids) => {
+                    for (const id of ids)
+                        scope.blocks?.delete(id);
+                },
+                line: (text) => {
+                    // Two views in one turn point to the same place, so the line goes in once.
+                    if (!scope.lines?.includes(text))
+                        (scope.lines ??= []).push(text);
+                },
+                ...(stream ? { stream } : {}),
+            });
+        }
+        case 'pass_rate': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const runs = watch ? list('runs', { watchId: watch.id }) : list('runs');
+            return withBlocks(passRateBlocks(runs, { ...(watch ? { dotId: watch.id } : {}) }), { scope: watch?.name ?? 'all dots' });
+        }
+        case 'flaky_by_spec': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const runs = watch ? list('runs', { watchId: watch.id }) : list('runs');
+            const days = typeof input.sinceDays === 'number' && Number.isFinite(input.sinceDays) ? input.sinceDays : 7;
+            return withBlocks(flakyBySpecBlocks(runs, { days, ...(watch ? { dotId: watch.id } : {}) }), { scope: watch?.name ?? 'all dots' });
+        }
+        case 'list_runs': {
+            const watch = str(input.dotId) || ctx.watch ? resolveWatch(input, ctx) : undefined;
+            const hours = typeof input.sinceHours === 'number' ? input.sinceHours : 24;
+            const since = new Date(Date.now() - hours * 3600_000).toISOString();
+            const limit = typeof input.limit === 'number' ? Math.min(50, input.limit) : 10;
+            let rows = newestFirst(watch ? list('runs', { watchId: watch.id }) : list('runs')).filter((r) => r.createdAt >= since);
+            if (str(input.kind))
+                rows = rows.filter((r) => r.kind === input.kind);
+            if (input.onlyProblems)
+                rows = rows.filter((r) => r.status === 'failed' || (r.verdict && !['pass', 'info'].includes(r.verdict.outcome)));
+            return { count: rows.length, runs: rows.slice(0, limit).map(summarizeRun) };
+        }
+        case 'get_run': {
+            const run = get('runs', String(input.runId ?? ''));
+            if (!run)
+                return { error: 'run not found' };
+            return {
+                ...summarizeRun(run),
+                steps: run.steps.map((s) => `${s.status}: ${s.label}${s.detail ? ` (${s.detail})` : ''}`),
+                failing: run.report?.cases
+                    .filter((c) => c.status === 'failed' || c.status === 'timedOut')
+                    .map((c) => ({ title: c.title, file: c.file, error: c.error?.slice(0, 400) })),
+                verdict: run.verdict,
+                actions: run.actions.map((a) => ({ kind: a.action.kind, target: a.action.target, result: a.result })),
+            };
+        }
+        case 'list_tickets_reviewed': {
+            const watch = resolveWatch(input, ctx);
+            const limit = typeof input.limit === 'number' ? Math.min(20, input.limit) : 5;
+            const rows = newestFirst(watch ? list('runs', { watchId: watch.id, kind: 'ticket_review' }) : list('runs', { kind: 'ticket_review' }));
+            return rows.slice(0, limit).map((r) => ({
+                runId: r.id,
+                ticket: r.trigger?.ticket?.key ?? r.trigger?.title,
+                title: r.trigger?.title,
+                headline: r.verdict?.headline,
+                risks: r.verdict?.findings.map((f) => f.title),
+                openQuestions: r.verdict?.openQuestions,
+                commentStatus: r.actions.find((a) => a.action.kind === 'ticket_comment')?.result ?? 'none',
+            }));
+        }
+        case 'rerun_tests': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const archived = archivedNote(watch);
+            if (archived)
+                return { queued: false, error: archived };
+            const grep = str(input.grep);
+            const specs = Array.isArray(input.specs) ? input.specs.filter((s) => typeof s === 'string') : undefined;
+            const minute = new Date().toISOString().slice(0, 16);
+            const jobId = enqueue({
+                kind: 'rerun',
+                watchId: watch.id,
+                dedupeKey: `rerun:${watch.id}:${grep ?? ''}:${minute}`,
+                payload: { grep, specs, requestedBy: 'chat' },
+            });
+            return jobId
+                ? { queued: true, jobId, dot: watch.name, grep: grep ?? null }
+                : { queued: false, reason: 'An identical rerun was queued in the last minute.' };
+        }
+        case 'review_pr': {
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const repo = str(input.repo);
+            // Every app repo of the dot counts, not only the first one (a dot of several repos, KAT-405).
+            const appRepos = watchRepos(watch).filter((r) => r.role === 'app');
+            if (repo && !appRepos.length && !watch.repo)
+                return { error: `${watch.name} watches no repo, so it cannot review pull requests.` };
+            const namedApps = appRepos.length ? appRepos.map((r) => `${r.owner}/${r.name}`) : watch.repo ? [`${watch.repo.owner}/${watch.repo.name}`] : [];
+            if (repo && !namedApps.some((n) => n.toLowerCase() === repo.toLowerCase()))
+                return { error: `${watch.name} watches ${namedApps.join(', ')}, not ${repo}, so it cannot review that PR.` };
+            const parsed = parseReviewTarget({ pr: input.pr, sha: input.sha, base: input.base, head: input.head });
+            if (!parsed.ok)
+                return { error: parsed.error };
+            const res = await requestReview(watch, parsed.target, { requestedBy: 'chat', ...(repo && namedApps.length > 1 ? { repo } : {}) });
+            if (!res.ok)
+                return { error: res.error };
+            if ('pr' in parsed.target) {
+                const full = repo ??
+                    (watch.repo ? `${watch.repo.owner}/${watch.repo.name}` : watchRepos(watch)[0] ? `${watchRepos(watch)[0].owner}/${watchRepos(watch)[0].name}` : '');
+                const pr = parsed.target.pr;
+                if (full)
+                    cardLater(async () => {
+                        const card = await buildObjectCard({ kind: 'github_pr', repo: full, number: pr }, watch);
+                        return card.ok ? card.value : null;
+                    }, 'review_pr');
+            }
+            return { queued: !res.duplicate, duplicate: res.duplicate, jobId: res.jobId, kind: res.jobKind, title: res.title, dot: watch.name };
+        }
+        case 'get_memory': {
+            const watch = resolveWatch(input, ctx);
+            return listMemory(watch?.id).map((m) => ({ id: m.id, kind: m.kind, text: m.text, source: m.source }));
+        }
+        case 'add_memory': {
+            // A dot's memory is the editor's (POST /api/memory), so a member's chat may not write it either (KAT-364).
+            if (chatScope.getStore()?.role === 'member')
+                return { error: PHONE_BLOCKED_MESSAGE };
+            const watch = resolveWatch(input, ctx);
+            if (!watch)
+                return { error: 'Which dot? More than one exists; pass dotId.' };
+            const kinds = ['flaky_spec', 'env_quirk', 'convention', 'decision', 'note'];
+            const kind = kinds.find((k) => k === input.kind) ?? 'note';
+            const item = addMemory(watch.id, String(input.text ?? ''), kind, 'user');
+            return { saved: true, id: item.id, kind: item.kind };
+        }
+        case 'probe_status': {
+            const watch = resolveWatch(input, ctx);
+            const rows = list('probe_state');
+            const scoped = watch ? rows.filter((r) => !r.watchId || r.watchId === watch.id) : rows;
+            if (!scoped.length) {
+                const urls = watch?.probes.map((p) => p.url) ?? [];
+                return { probes: [], note: urls.length ? `No probe results yet for ${urls.join(', ')}.` : 'No probes configured.' };
+            }
+            return { probes: scoped };
+        }
+        default:
+            return { error: `unknown tool ${name}` };
+    }
+}
+function loadHistory(scope) {
+    try {
+        // Dot updates (KAT-143) are reports, not turns of the conversation.
+        const rows = newestFirst(list('messages', { watchId: scope }))
+            .filter((r) => r.kind !== 'update')
+            .slice(0, 20)
+            .reverse();
+        const history = rows.map((r) => ({ role: r.role, content: r.content }));
+        while (history.length && history[0].role !== 'user')
+            history.shift();
+        return history;
+    }
+    catch {
+        return [];
+    }
+}
+function saveMessage(scope, role, content, blocks, kind, id, work) {
+    try {
+        return insert('messages', {
+            ...(id ? { id } : {}),
+            watchId: scope,
+            role,
+            content,
+            ...(kind ? { kind } : {}),
+            ...(blocks?.length ? { blocks } : {}),
+            ...(work ? { work } : {}),
+        }).id;
+    }
+    catch (err) {
+        console.warn('[chat] could not store message', err);
+        return undefined;
+    }
+}
+/** The most step lines one turn keeps. */
+const MAX_STEPS = 20;
+/**
+ * Entry point for POST /api/chat. Loads history, streams the reply, stores both turns.
+ * A report-scoped chat keeps its own history (scope `report:<id>`).
+ */
+export async function runChat(input, onDelta, onTool, onEvent) {
+    const startedAt = Date.now();
+    const page = input.reportId ? getReport(input.reportId) : undefined;
+    const dotId = input.dotId ?? page?.watchId;
+    const watch = dotId ? (get('watches', dotId) ?? undefined) : undefined;
+    const scope = page ? `report:${page.id}` : (watch?.id ?? 'all');
+    const save = input.channel !== 'call';
+    const history = loadHistory(scope);
+    const askId = save ? saveMessage(scope, 'user', input.text) : undefined;
+    const origin = input.origin ??
+        (input.channel === 'call' || page
+            ? undefined
+            : {
+                channel: 'web',
+                ...(askId ? { messageId: askId } : {}),
+                text: input.text.slice(0, 200),
+                // Asked in the all-dots chat: the result replies there (KAT-143).
+                ...(scope === 'all' ? { scope: 'all' } : {}),
+                // Asked in a lead's chat: a member does the work, and the result replies here as "From <member>" (KAT-405).
+                ...(watch && isLead(watch) ? { scope: 'lead', leadId: watch.id } : {}),
+            });
+    const req = { watch, history, text: input.text };
+    if (input.channel)
+        req.channel = input.channel;
+    if (page) {
+        req.reportId = page.id;
+        const context = reportContextFor(page.id);
+        if (context)
+            req.context = context;
+    }
+    // A question that a working view answers gets the view, picked by a cheap rule and built from stored
+    // runs; the chat model is not called (KAT-247). "Since the last merge" and "today" pick the runs.
+    const view = await pickChatView(input.text, { watch, channel: input.channel ?? 'chat', ...(page ? { reportId: page.id } : {}) });
+    // The release question of a lead: Ready, Ready with risk or Not ready, built from stored rows with no model call (KAT-405).
+    if (view?.view === 'release' && watch && isLead(watch)) {
+        const call = releaseCallFor(watch, view.milestone);
+        const parsed = parseChatBlock(releaseBlock(watch, call, 'release_call'));
+        const block = parsed.ok ? parsed.block : undefined;
+        const reply = releaseText(watch, call, input.channel, config.publicUrl, input.trust);
+        onDelta(reply);
+        if (block && (input.channel ?? 'chat') === 'chat')
+            onEvent?.({ type: 'block', block });
+        if (save)
+            saveMessage(scope, 'assistant', reply, block && (input.channel ?? 'chat') === 'chat' ? [block] : undefined);
+        return reply;
+    }
+    if (view?.view === 'triage') {
+        const parsed = parseChatBlock(buildTriageBlock(watch, { window: triageWindowOf(input.text) }));
+        const block = parsed.ok ? parsed.block : undefined;
+        const reply = block?.kind === 'triage' ? triageLine(block, watch?.name) : 'The failure triage could not be built.';
+        onDelta(reply);
+        if (block)
+            onEvent?.({ type: 'block', block });
+        if (save)
+            saveMessage(scope, 'assistant', reply, block ? [block] : undefined);
+        return reply;
+    }
+    // The Reasoning card (KAT-374): summary lines the backend returned, the tool results, and the turn's model_calls rows.
+    const steps = [];
+    const tools = [];
+    const callIds = [];
+    const step = (line) => {
+        if (steps.length >= MAX_STEPS || steps.at(-1) === line)
+            return;
+        steps.push(line);
+        onEvent?.({ type: 'reasoning', text: line });
+    };
+    const state = {
+        emit: (e) => {
+            if (e.type === 'tool_result')
+                tools.push({ name: e.name, summary: e.summary, ...(e.error ? { error: true } : {}) });
+            onEvent?.(e);
+        },
+        stream: Boolean(onEvent),
+        pending: [],
+        question: input.text,
+        userText: input.text,
+        ...(input.channel ? { channel: input.channel } : {}),
+        ...(origin ? { origin } : {}),
+        ...(input.role ? { role: input.role } : {}),
+        ...(watch ? { watch } : {}),
+        messageId: newId(),
+    };
+    const tool = (name, toolInput) => {
+        onTool(name, toolInput);
+        onEvent?.({ type: 'tool', name, input: toolInput });
+    };
+    // A dot with Team notes streams nothing while the model writes: a copy of the notes would show in the chat before the cut. The turn's
+    // text is held, and the cut answer goes out in one piece when the model is done (KAT-383).
+    const held = [];
+    const emit = teamNotes(watch) ? (t) => void held.push(t) : onDelta;
+    try {
+        let reply;
+        // A dot at its daily model cap answers no new question until the reset (KAT-362). A view answered above spent no call and still went out.
+        const capped = watch ? capState(watch) : undefined;
+        if (watch && capped?.reached) {
+            reply = `${capLine(capped)}. ${watch.name} used ${capped.used} of ${capped.cap} model calls today, so chat answers and new reviews wait. Raise or remove the cap in the dot settings to go on now.`;
+            emit(reply);
+        }
+        else {
+            try {
+                const ask = () => getLlm().chat(req, emit, tool);
+                reply = await collectModelCalls(callIds, () => withReasoning(step, () => chatScope.run(state, () => (watch ? withModelContext(watch.id, 'chat', ask) : ask()))));
+            }
+            catch (err) {
+                // No model could answer (KAT-102): say so in the chat, and never make up an answer.
+                if (!(err instanceof ModelUnavailableError))
+                    throw err;
+                reply = `Model unavailable: ${err.reason}. Ask again once a model works; Setup shows when it is checked again.`;
+                emit(reply);
+            }
+        }
+        // A line the turn must carry (the designed test cases and their link) goes at the end when the model left it out.
+        const missing = (state.lines ?? []).filter((l) => !reply.includes(l.includes('](') ? l.slice(l.indexOf('](') + 2, -1) : l));
+        // Server-built lines carry links the server wrote: the designed test cases and the view of a turn (KAT-380).
+        for (const l of state.lines ?? [])
+            input.trust?.addMarkdown(l);
+        if (missing.length) {
+            const extra = `\n\n${missing.join('\n')}`;
+            emit(extra);
+            reply += extra;
+        }
+        // The dot's team notes went into the turn as context. A copy of them in the answer is cut out before it is stored or posted (KAT-383).
+        reply = scrubEcho(reply, teamNotes(watch));
+        if (held.length)
+            onDelta(reply);
+        // Every PR, ticket, run, and defect the answer names carries its title and link (KAT-225). The text
+        // streamed as written (a dot with Team notes streams the cut text); this final text replaces it, and it is the one stored and sent to Slack.
+        reply = await renderRefs(reply, {
+            ...(watch ? { dotId: watch.id } : {}),
+            format: input.refFormat ?? (input.channel === 'call' ? 'text' : 'markdown'),
+            absolute: input.channel === 'slack' || input.channel === 'call',
+            ...(input.trust ? { trust: input.trust } : {}),
+        });
+        const tokens = tokensOfCalls(callIds);
+        const work = {
+            elapsedMs: Date.now() - startedAt,
+            steps: steps.length || tools.length,
+            ...(steps.length ? { summary: steps } : {}),
+            ...(tools.length ? { tools } : {}),
+            ...(tokens !== undefined ? { tokens } : {}),
+        };
+        onEvent?.({ type: 'work', work });
+        input.onWork?.(work);
+        // The reply is stored under the id its link line named, so the link from Slack or a call opens this answer (KAT-366).
+        if (save)
+            saveMessage(scope, 'assistant', reply, state.blocks ? [...state.blocks.values()] : undefined, undefined, state.messageId, work);
+        // A call is not stored, but a view composed in it is: the line it spoke points to the chat, where the view must be (KAT-366).
+        else if (state.blocks && [...state.blocks.values()].some((b) => b.kind === 'view'))
+            saveMessage(scope, 'assistant', reply, [...state.blocks.values()].filter((b) => b.kind === 'view'), 'call_view', state.messageId);
+        return reply;
+    }
+    finally {
+        // A view that streamed and was never finished (the turn failed, or the call was never made) leaves the client.
+        for (const s of state.viewStreams ?? [])
+            s.close();
+        await Promise.allSettled(state.pending);
+        if (state.runId) {
+            try {
+                finishRun(state.runId, 'done');
+            }
+            catch {
+                /* run already gone */
+            }
+        }
+    }
+}
+export { runChat as chat, runChat as answerChat };
+//# sourceMappingURL=chat.js.map