@alexkroman1/aai-cli 5.14.0 → 6.1.0

package/dist/templates/support-line/graph.ts

@@ -0,0 +1,224 @@
+/**
+ * The corrective-RAG loop, node by node.
+ *
+ * This is the port of the self-RAG / CRAG graph (see `prompts.ts` for the
+ * attribution). Their control flow is edges between nodes; here it is a `while`
+ * loop in one tool body, and the node names survive in {@link AnswerTrace.steps}
+ * so a run is still readable as the graph it came from:
+ *
+ * ```text
+ * retrieve → grade_documents → decide_to_generate
+ *                                ├─ no relevant docs → transform_query → retrieve
+ *                                └─ generate → grade_generation_v_documents
+ *                                                ├─ not grounded → generate (once)
+ *                                                └─ grade_generation_v_question
+ *                                                     ├─ not useful → transform_query
+ *                                                     └─ done
+ * ```
+ *
+ * **The budget is the mechanism, not the prompt.** A graph with a
+ * `transform_query` edge can cycle, and their notebooks bound it with a recursion
+ * limit that raises on hit. A caller is holding the line, so the bound here is
+ * two attempts and one regeneration — {@link MAX_ATTEMPTS} — and running out is
+ * an ANSWER (`exhausted`, the caller is offered a ticket) rather than an error.
+ * An agent that cannot say "I don't have that documented" is the failure the
+ * whole grading apparatus exists to prevent, so it has to be a reachable state.
+ *
+ * **Documents are graded CONCURRENTLY.** Their loop is sequential because a
+ * notebook does not care; four serial grader calls is four round trips of dead
+ * air on a phone. The grades are independent, so the fan-out is free.
+ */
+
+import type { GenerateFn } from "@alexkroman1/aai";
+import {
+  ANSWER_SYSTEM,
+  ANSWERS_SYSTEM,
+  binaryScore,
+  DOC_GRADER_SYSTEM,
+  GROUNDED_SYSTEM,
+  REWRITE_SYSTEM,
+} from "./prompts.ts";
+import type { AnswerTrace, Doc, GradedDoc, TraceStep } from "./shared.ts";
+import { formatDoc, retrieve } from "./shared.ts";
+
+/** Retrieve-and-answer attempts, i.e. one query rewrite. */
+export const MAX_ATTEMPTS = 2;
+/** Regenerations after a "not grounded" verdict, within one attempt. */
+export const MAX_REGENERATIONS = 1;
+
+function step(trace: AnswerTrace, node: string, detail: string): void {
+  const entry: TraceStep = { node, detail };
+  trace.steps.push(entry);
+}
+
+/** `grade_documents` — one closed question per document, all at once. */
+async function gradeDocuments(
+  generate: GenerateFn,
+  question: string,
+  docs: Doc[],
+): Promise<GradedDoc[]> {
+  return await Promise.all(
+    docs.map(async (doc) => {
+      const { object } = await generate({
+        system: DOC_GRADER_SYSTEM,
+        prompt: `Caller's question: ${question}\n\nDocument:\n${formatDoc(doc)}`,
+        schema: binaryScore,
+      });
+      return {
+        id: doc.id,
+        title: doc.title,
+        relevant: object.score === "yes",
+        reason: object.reason,
+      };
+    }),
+  );
+}
+
+/** `transform_query` — their question re-writer, aimed at a keyword index. */
+async function transformQuery(generate: GenerateFn, question: string): Promise<string> {
+  const { text } = await generate({
+    system: REWRITE_SYSTEM,
+    prompt: `Caller's question: ${question}`,
+  });
+  const rewritten = text.trim().replace(/^["']|["']$/g, "");
+  // A rewriter that returns nothing usable must not empty the query — that
+  // would retrieve zero documents and read as "we have nothing on this".
+  return rewritten.length > 0 ? rewritten : question;
+}
+
+/** `generate` — the answer, from the graded-relevant documents only. */
+async function generateAnswer(
+  generate: GenerateFn,
+  question: string,
+  docs: Doc[],
+): Promise<string> {
+  const { text } = await generate({
+    system: ANSWER_SYSTEM,
+    prompt: `Documents:\n\n${docs.map(formatDoc).join("\n\n")}\n\nCaller's question: ${question}`,
+  });
+  return text.trim();
+}
+
+/** The two generation graders — same closed question, different subject. */
+async function grade(
+  generate: GenerateFn,
+  system: string,
+  prompt: string,
+): Promise<{ pass: boolean; reason: string }> {
+  const { object } = await generate({ system, prompt, schema: binaryScore });
+  return { pass: object.score === "yes", reason: object.reason };
+}
+
+/**
+ * Run the graph for one caller question. Never throws for a bad ANSWER — only
+ * for a broken model call, which is the tool's to report.
+ */
+export async function runCorrectiveRag(
+  generate: GenerateFn,
+  question: string,
+): Promise<AnswerTrace> {
+  const trace: AnswerTrace = {
+    question,
+    query: question,
+    rewrites: 0,
+    steps: [],
+    docs: [],
+    answer: null,
+    grounded: null,
+    useful: null,
+    exhausted: false,
+  };
+
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    const retrieved = retrieve(trace.query);
+    step(trace, "retrieve", `${retrieved.length} document(s) for "${trace.query}"`);
+
+    const graded = await gradeDocuments(
+      generate,
+      question,
+      retrieved.map((one) => one.doc),
+    );
+    trace.docs = graded;
+    const relevant = retrieved.filter((one) => graded.find((g) => g.id === one.doc.id)?.relevant);
+    step(trace, "grade_documents", `${relevant.length} of ${graded.length} relevant`);
+
+    // `decide_to_generate`: nothing relevant means the retrieval was wrong, not
+    // that the answer is unknown — so rewrite and try once more before giving up.
+    if (relevant.length === 0) {
+      if (attempt < MAX_ATTEMPTS) {
+        trace.query = await transformQuery(generate, question);
+        trace.rewrites++;
+        step(trace, "transform_query", `retrying as "${trace.query}"`);
+        continue;
+      }
+      trace.exhausted = true;
+      step(trace, "decide_to_generate", "no relevant documents, and no attempts left");
+      return trace;
+    }
+
+    const docs = relevant.map((one) => one.doc);
+    const facts = docs.map(formatDoc).join("\n\n");
+    let answer = await generateAnswer(generate, question, docs);
+    step(trace, "generate", `answered from ${docs.map((d) => d.id).join(", ")}`);
+
+    // `grade_generation_v_documents`: is it grounded? A regeneration is worth
+    // one shot — the same documents with the ungrounded attempt now visible.
+    let grounded = await grade(
+      generate,
+      GROUNDED_SYSTEM,
+      `Facts:\n\n${facts}\n\nAnswer: ${answer}`,
+    );
+    for (let redo = 0; !grounded.pass && redo < MAX_REGENERATIONS; redo++) {
+      step(trace, "grade_generation_v_documents", `not grounded: ${grounded.reason}`);
+      answer = await generateAnswer(generate, question, docs);
+      step(trace, "generate", "regenerated");
+      grounded = await grade(generate, GROUNDED_SYSTEM, `Facts:\n\n${facts}\n\nAnswer: ${answer}`);
+    }
+    trace.answer = answer;
+    trace.grounded = grounded.pass;
+    step(
+      trace,
+      "grade_generation_v_documents",
+      grounded.pass ? "grounded" : `still not grounded: ${grounded.reason}`,
+    );
+    if (!grounded.pass) {
+      // An ungrounded answer is never spoken. Two regenerations that both
+      // invented something is a signal about the documents, not the phrasing.
+      trace.answer = null;
+      trace.exhausted = true;
+      return trace;
+    }
+
+    // `grade_generation_v_question`: grounded is not the same as useful.
+    const useful = await grade(
+      generate,
+      ANSWERS_SYSTEM,
+      `Question: ${question}\n\nAnswer: ${answer}`,
+    );
+    trace.useful = useful.pass;
+    step(
+      trace,
+      "grade_generation_v_question",
+      useful.pass ? "useful" : `not useful: ${useful.reason}`,
+    );
+    if (useful.pass) return trace;
+
+    if (attempt < MAX_ATTEMPTS) {
+      trace.query = await transformQuery(generate, question);
+      trace.rewrites++;
+      step(trace, "transform_query", `retrying as "${trace.query}"`);
+      trace.answer = null;
+      trace.grounded = null;
+      trace.useful = null;
+      continue;
+    }
+    // Out of attempts holding an answer that is grounded but beside the point.
+    // It is still the best thing we have, so it is returned WITH its verdict —
+    // the tool tells the model to offer a ticket alongside it.
+    trace.exhausted = true;
+    return trace;
+  }
+
+  trace.exhausted = true;
+  return trace;
+}

package/dist/templates/support-line/knowledge.json

@@ -0,0 +1,65 @@
+{
+  "product": "Meridian Fibre",
+  "docs": [
+    {
+      "id": "D1",
+      "title": "Router lights and what they mean",
+      "topic": "connection",
+      "text": "The Meridian hub has three lights. A solid white power light means the hub is on. A solid blue broadband light means the line is synced. A flashing blue light means the hub is still syncing, which can take up to fifteen minutes after a power cut. A red broadband light means the line is down: check the fibre cable is pushed fully into the grey socket, then leave the hub powered on for fifteen minutes before doing anything else."
+    },
+    {
+      "id": "D2",
+      "title": "Rebooting the hub",
+      "topic": "connection",
+      "text": "Power the hub off at the wall, wait thirty seconds, and power it back on. Do not use the pinhole reset button unless an agent asks you to: that clears your wifi name and password as well, and every device in the house then has to be reconnected. A normal reboot keeps all your settings."
+    },
+    {
+      "id": "D3",
+      "title": "Slow speeds over wifi",
+      "topic": "speed",
+      "text": "Wifi speed drops with distance and with walls. Keep the hub off the floor, out of a cupboard, and away from the microwave and the TV. A wired device plugged into a yellow ethernet port is the only way to measure your real line speed; a speed test over wifi measures the wifi, not the fibre. If a wired test is more than twenty percent below your plan speed for three days running, that is a line fault and we will send an engineer."
+    },
+    {
+      "id": "D4",
+      "title": "Your bill and when it is taken",
+      "topic": "billing",
+      "text": "Bills are issued on the first of the month and the direct debit is taken eight working days later. Your first bill also carries a part month charge for the days between your activation date and the first of the month, so it is usually larger than the ones that follow. You can change the payment date once every twelve months from the account page."
+    },
+    {
+      "id": "D5",
+      "title": "Cancelling your contract",
+      "topic": "account",
+      "text": "You can cancel at any time by giving thirty days notice. If you are still inside your minimum term, an early exit fee applies: it is the remaining months of the term multiplied by your monthly price, capped at six months. Notice starts on the day we receive it, not the day you post the equipment back. The hub must be returned within fourteen days of the service ending or a fifty pound non return fee is charged."
+    },
+    {
+      "id": "D6",
+      "title": "Cancelling or rebooking an engineer visit",
+      "topic": "appointments",
+      "text": "An engineer visit can be moved or cancelled free of charge until midnight the day before. After that, and for a missed appointment where nobody over eighteen was at the property, a sixty pound abortive visit charge applies. Rebooking is done from the appointments page or by asking us on the phone; the next available slot is usually within three working days."
+    },
+    {
+      "id": "D7",
+      "title": "Moving home",
+      "topic": "account",
+      "text": "Tell us at least four weeks before you move. If Meridian Fibre is available at the new address we move the service and your contract continues unchanged, with a one off activation charge of thirty five pounds. If we cannot serve the new address, the contract ends with no early exit fee, which is the one case where the fee is waived."
+    },
+    {
+      "id": "D8",
+      "title": "Checking for an outage in your area",
+      "topic": "connection",
+      "text": "Area outages are listed on the status page and the phone line plays a recorded message naming the affected postcodes. During a confirmed outage there is nothing to fix at your end: rebooting the hub will not help and an engineer cannot be booked until the area work is closed. Compensation of eight pounds per full day starts after the second full day of a confirmed total loss of service."
+    },
+    {
+      "id": "D9",
+      "title": "Static IP addresses",
+      "topic": "advanced",
+      "text": "A static IP address is available on business plans only, at five pounds a month. It cannot be added to a residential plan; upgrading to business is the only route, and that starts a new twelve month term. Port forwarding, by contrast, works on every plan and needs no static IP."
+    },
+    {
+      "id": "D10",
+      "title": "Data caps and traffic management",
+      "topic": "speed",
+      "text": "There is no data cap on any Meridian Fibre plan and no traffic management at peak times. If your speed drops every evening at the same time, that is congestion in your own home, usually a device backing up or streaming in the background, and not something we apply."
+    }
+  ]
+}

package/dist/templates/support-line/prompts.ts

@@ -0,0 +1,95 @@
+/**
+ * The graders, the rewriter and the answer prompt — and where they come from.
+ *
+ * **Adapted from LangGraph's self-RAG and corrective-RAG notebooks** (MIT,
+ * <https://github.com/langchain-ai/langgraph>,
+ * `docs/docs/tutorials/rag/langgraph_self_rag.ipynb` and
+ * `langgraph_crag.ipynb`), whose graders are `ChatPromptTemplate`s bound to
+ * small pydantic models with one field: a binary `"yes"`/`"no"` score.
+ *
+ * | self-RAG / CRAG node | here |
+ * | --- | --- |
+ * | `retrieval_grader` (`GradeDocuments`) | {@link DOC_GRADER_SYSTEM} + {@link binaryScore} |
+ * | `question_rewriter` | {@link REWRITE_SYSTEM} |
+ * | `rag_chain` (`rlm/rag-prompt`) | {@link ANSWER_SYSTEM} |
+ * | `hallucination_grader` (`GradeHallucinations`) | {@link GROUNDED_SYSTEM} |
+ * | `answer_grader` (`GradeAnswer`) | {@link ANSWERS_SYSTEM} |
+ *
+ * **The binary score is the load-bearing part and it is kept verbatim in
+ * shape.** Their whole design rests on asking a model one closed question at a
+ * time rather than "is this good?", because a closed question is one a small
+ * model answers reliably and a caller's answer can be routed on. `reason` is an
+ * addition: it costs a few tokens, it is what the sidebar renders per document,
+ * and asking for it is the cheapest way to see WHY a grader is being strict.
+ *
+ * What is adapted is the audience. Theirs answer into a notebook and may take
+ * three sentences of markdown; ours is read down a phone by a support line, so
+ * {@link ANSWER_SYSTEM} asks for two spoken sentences and forbids the "based on
+ * the provided context" preamble that a caller hears as evasion.
+ */
+
+import { z } from "zod";
+
+/**
+ * Their `GradeDocuments` / `GradeHallucinations` / `GradeAnswer`, as one
+ * schema — all three are the same closed question with a different subject, and
+ * `ctx.generate({ schema })` constrains the model to it.
+ */
+export const binaryScore = z.object({
+  score: z.enum(["yes", "no"]).describe("Binary score, 'yes' or 'no'"),
+  reason: z.string().max(200).describe("One short sentence of justification"),
+});
+
+export type BinaryScore = z.infer<typeof binaryScore>;
+
+/** Their `retrieval_grader`: deliberately NOT a stringent test. */
+export const DOC_GRADER_SYSTEM = [
+  "You are a grader assessing whether a retrieved support document is relevant",
+  "to a caller's question. If the document contains keywords or meaning related",
+  "to the question, grade it relevant. This does not need to be a stringent",
+  "test — the goal is to filter out erroneous retrievals, not to pick the single",
+  "best document. Documents about a NEIGHBOURING subject (cancelling an",
+  "appointment when the caller asked about cancelling a contract) are NOT",
+  "relevant; answering from one of those is the specific mistake you exist to",
+  "prevent.",
+  "Give a binary score, 'yes' or 'no'.",
+].join(" ");
+
+/** Their `question_rewriter`, retargeted from a vectorstore to a keyword index. */
+export const REWRITE_SYSTEM = [
+  "You rewrite a caller's spoken question into a better search query for a",
+  "support knowledge base that matches on WORDS, not meaning.",
+  "Reason about what the caller actually means, then write the terms a support",
+  "document about it would itself use — including the words they did not say.",
+  '"my internet keeps dying at night" should become something like',
+  '"evening slowdown congestion speed drops peak time".',
+  "Reply with the query alone: no quotes, no explanation, under fifteen words.",
+].join(" ");
+
+/** Their `rag_chain` prompt, rewritten for a voice line. */
+export const ANSWER_SYSTEM = [
+  "You are a support agent answering a caller using ONLY the documents given to",
+  "you. If the documents do not contain the answer, say you do not have it",
+  "documented — do not fill the gap from general knowledge.",
+  "Two sentences maximum, spoken plainly, as you would say them out loud.",
+  "Never say 'based on the provided context' or 'according to the documents':",
+  "the caller hears that as evasion. Just answer.",
+  "Give the specific number, fee or step where the documents have one.",
+].join(" ");
+
+/** Their `hallucination_grader`. */
+export const GROUNDED_SYSTEM = [
+  "You are a grader assessing whether an answer is grounded in and supported by",
+  "a set of facts. Give a binary score, 'yes' or 'no'.",
+  "'Yes' means every claim in the answer is supported by the facts.",
+  "An answer that says it does not know is grounded — refusing to guess is",
+  "supported by any set of facts.",
+].join(" ");
+
+/** Their `answer_grader`: grounded is not the same as useful. */
+export const ANSWERS_SYSTEM = [
+  "You are a grader assessing whether an answer actually resolves the caller's",
+  "question. Give a binary score, 'yes' or 'no'.",
+  "'Yes' means the caller now knows what to do or what is true.",
+  "An answer that is correct but about something adjacent scores 'no'.",
+].join(" ");

package/dist/templates/support-line/shared.ts

@@ -0,0 +1,240 @@
+/**
+ * The knowledge base, the retriever, and what the browser is shown.
+ *
+ * **The retriever is lexical, and that is a deliberate difference from the
+ * notebooks this template ports.** Their self-RAG and CRAG graphs retrieve from
+ * a Chroma vectorstore over OpenAI embeddings; this SDK has no vector store
+ * (`ctx.vector` was removed — see the root guide), and a template that needed
+ * one would be a template nobody can run. So retrieval here is term overlap
+ * with an inverse-document-frequency weight, which is genuinely worse at
+ * meaning and genuinely fine at words.
+ *
+ * That makes the corrective loop MORE valuable rather than less, which is the
+ * point worth taking away: CRAG exists because retrieval is imperfect, and a
+ * weaker retriever is exactly the case its grader and its query rewriter were
+ * designed for. A caller saying "my internet keeps dying at night" retrieves
+ * nothing useful by words alone — the rewrite step is what turns it into
+ * "evening slowdown congestion peak time" and finds D10.
+ */
+
+import { type DeepReadonly, pushCapped, sessionSlot } from "@alexkroman1/aai";
+import knowledge from "./knowledge.json" with { type: "json" };
+
+export interface Doc {
+  id: string;
+  title: string;
+  topic: string;
+  text: string;
+}
+
+export const PRODUCT: string = knowledge.product;
+export const DOCS: Doc[] = knowledge.docs;
+
+export const TOPICS: string[] = [...new Set(DOCS.map((doc) => doc.topic))].sort();
+
+// ─── Retrieval ───────────────────────────────────────────────────────────────
+
+/** Words that match everything and therefore rank nothing. */
+const STOPWORDS = new Set([
+  "the",
+  "and",
+  "for",
+  "you",
+  "your",
+  "are",
+  "was",
+  "with",
+  "that",
+  "this",
+  "have",
+  "has",
+  "can",
+  "not",
+  "but",
+  "how",
+  "why",
+  "what",
+  "when",
+  "will",
+  "from",
+  "into",
+  "out",
+  "get",
+  "does",
+  "did",
+  "any",
+  "all",
+  "our",
+  "their",
+  "there",
+  "then",
+  "than",
+  "about",
+  "just",
+  "been",
+  "were",
+  "they",
+  "them",
+  "his",
+  "her",
+  "its",
+  "one",
+  "two",
+  "who",
+  "whom",
+  "some",
+]);
+
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((word) => word.length > 2 && !STOPWORDS.has(word));
+}
+
+/** Term → how many documents contain it. Computed once at module load. */
+const DOC_FREQUENCY = new Map<string, number>();
+const DOC_TOKENS = new Map<string, string[]>();
+for (const doc of DOCS) {
+  const tokens = tokenize(`${doc.title} ${doc.topic} ${doc.text}`);
+  DOC_TOKENS.set(doc.id, tokens);
+  for (const term of new Set(tokens)) {
+    DOC_FREQUENCY.set(term, (DOC_FREQUENCY.get(term) ?? 0) + 1);
+  }
+}
+
+/** How many documents one retrieval returns before grading. */
+export const RETRIEVE_K = 4;
+
+export interface Retrieved {
+  doc: Doc;
+  score: number;
+}
+
+/**
+ * The `retrieve` node: top-k by idf-weighted term overlap.
+ *
+ * A term in one document is worth much more than a term in eight — without the
+ * weight, "fibre" and "hub" (in nearly every document) drown the one word that
+ * actually distinguishes the caller's question.
+ */
+export function retrieve(query: string, k: number = RETRIEVE_K): Retrieved[] {
+  const terms = new Set(tokenize(query));
+  if (terms.size === 0) return [];
+  const scored: Retrieved[] = [];
+  for (const doc of DOCS) {
+    const tokens = DOC_TOKENS.get(doc.id) ?? [];
+    let score = 0;
+    for (const term of terms) {
+      const hits = tokens.filter((token) => token === term).length;
+      if (hits === 0) continue;
+      const frequency = DOC_FREQUENCY.get(term) ?? 1;
+      // Diminishing returns per repeat, so one long document cannot win on
+      // repetition alone.
+      score += Math.log(1 + hits) * Math.log(DOCS.length / frequency + 1);
+    }
+    if (score > 0) scored.push({ doc, score });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, k);
+}
+
+/** One document as the answer prompt sees it. */
+export function formatDoc(doc: Doc): string {
+  return `[${doc.id}] ${doc.title}\n${doc.text}`;
+}
+
+// ─── The trace ───────────────────────────────────────────────────────────────
+// Their graph is watched by streaming node names to a notebook. A caller hears
+// none of that, so the run records itself and the browser renders it.
+
+export interface GradedDoc {
+  id: string;
+  title: string;
+  relevant: boolean;
+  reason: string;
+}
+
+export interface TraceStep {
+  /** The node's name, spelled as their graph spells it. */
+  node: string;
+  detail: string;
+}
+
+export interface AnswerTrace {
+  question: string;
+  /** The query retrieval actually ran on — rewritten, if it was. */
+  query: string;
+  rewrites: number;
+  steps: TraceStep[];
+  docs: GradedDoc[];
+  answer: string | null;
+  /** `null` until the hallucination grader has run. */
+  grounded: boolean | null;
+  /** `null` until the answer grader has run. */
+  useful: boolean | null;
+  /** True when the loop gave up and the caller should be offered a ticket. */
+  exhausted: boolean;
+}
+
+export interface Ticket {
+  reference: string;
+  question: string;
+  /** Server-side only — the projection never carries it. */
+  callback: string;
+}
+
+export interface SupportState {
+  /** The most recent run, which is what the sidebar renders. */
+  trace: AnswerTrace | null;
+  /** Every question this call has asked, capped. */
+  asked: string[];
+  ticket: Ticket | null;
+  ticketCounter: number;
+}
+
+export const MAX_ASKED = 20;
+
+export function emptySupportState(): SupportState {
+  return { trace: null, asked: [], ticket: null, ticketCounter: 0 };
+}
+
+export const supportSlot = sessionSlot("support", emptySupportState);
+
+/**
+ * The call as a READ hands it out: deep-frozen, and typed to say so.
+ *
+ * {@link supportView} takes this rather than {@link SupportState}, which is the
+ * widening a deep-readonly slot forces and the reason it is worth doing: a
+ * mutable state still satisfies it, so a call with an `update` draft is
+ * unaffected, while a projection that WOULD have mutated stops compiling
+ * instead of throwing at its first call.
+ */
+export type FrozenSupportState = DeepReadonly<SupportState>;
+
+export function recordQuestion(state: SupportState, question: string): void {
+  pushCapped(state.asked, question, MAX_ASKED);
+}
+
+// ─── The projection ──────────────────────────────────────────────────────────
+
+export interface SupportView {
+  product: string;
+  trace: DeepReadonly<AnswerTrace> | null;
+  asked: readonly string[];
+  /** The reference only — the callback number stays on the server. */
+  ticket: string | null;
+}
+
+/**
+ * What the browser sees. The `ticket` field is why this is a projection rather
+ * than the state itself: a ticket carries the caller's phone number, and
+ * `syncState` is where you decide what leaves the server.
+ */
+export function supportView(state: FrozenSupportState): SupportView {
+  return {
+    product: PRODUCT,
+    trace: state.trace,
+    asked: state.asked,
+    ticket: state.ticket?.reference ?? null,
+  };
+}

package/dist/templates/support-line/system-prompt.md

@@ -0,0 +1,17 @@
+You are the automated support line for Meridian Fibre, a home broadband provider. You are on a phone call. Answers are one or two sentences, spoken plainly, no lists and no markdown.
+
+The one rule that matters:
+
+- You do not know anything about Meridian Fibre. Everything you say about the product, its prices, its fees, its equipment or its process must come from `answer_question`. If you find yourself about to state a fee or a timescale you did not just get from that tool, stop and call it.
+- `answer_question` checks itself. It retrieves, grades what it retrieved, rewrites the question and retries if the retrieval was poor, and refuses to hand you an answer it could not ground in a document. Trust its verdict over your own instinct.
+
+Running a call:
+
+- The caller is waiting while the lookup runs, so say a short "let me check that for you" before calling `answer_question` — never in silence.
+- Give the answer it returns in your own words, keeping every number exactly as it came back.
+- When it returns no answer, say plainly that you do not have that documented. Do not guess, and do not soften it into a maybe. Offer to log a ticket.
+- When it returns an answer with a caveat, give the answer and then offer the ticket.
+- To log a ticket, ask for a callback number, call `log_ticket`, and read the reference back digit by digit.
+- Use `list_topics` when the caller does not know what to ask, or to say what you can help with after a failed lookup.
+
+Manners: one question at a time, no jargon the caller did not use first, and never blame the caller for the fault.