thursday-agent 0.1.2 → 0.2.0

package/features/ai/tools/mcp.tool.ts

@@ -22,9 +22,9 @@ const MAX_SCHEMAS = 8;
 export const mcpToolSpec = {
   [TOOL_NAMES.tool_search]: {
     name: TOOL_NAMES.tool_search,
-    description: `Fetch what a connected server's tools take, so they can be called.
-
-The Connected tools section names every server and every tool on it, and that is all it names: there is no description and no parameter schema, so a tool cannot be invoked from that list alone. Name a server and the tools on it, and this returns each one's description and its exact inputSchema. Then run one with \`${TOOL_NAMES.tool_call}\`.`,
+    // What it is, not when to reach for it: the Connected tools chapter says
+    // that the listing carries names alone and that this is how a schema is got
+    description: `Return the description and exact inputSchema of tools on a connected server, so they can be called with \`${TOOL_NAMES.tool_call}\`.`,
     parameters: z.object({
       server: z
         .string()
@@ -48,13 +48,13 @@ The Connected tools section names every server and every tool on it, and that is
       tool: z.string().describe("Its name, as search returned it."),
       args: z
         .record(z.string(), z.unknown())
-        .nullable()
+        .nullish()
         .describe(
           "Arguments matching the inputSchema search returned — do not guess. Null when it takes none.",
         ),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           "One short line for the user: what this call is for. Shown on their screen while it runs.",
         ),

package/features/ai/tools/memory.tool.ts

@@ -15,6 +15,7 @@ import {
   MANY_FACTS,
   MEMORY_ALWAYS_LISTED,
   MEMORY_INBOX,
+  type MemorySource,
 } from "@/features/memory/memory.schema";
 
 const GONE =
@@ -27,7 +28,12 @@ const WROTE =
 const tooMany = (path: string, count: number) =>
   ` ${path} carries ${count} facts — enough that it is worth tidying. Put it on screen with \`${TOOL_NAMES.memory_show}\` and ask which of it they no longer need.`;
 
-export const createMemoryTools = () => ({
+/**
+ * @param source Which hand these writes are recorded under. The runtime knows
+ * it without being told — the call, the read-back pass — so no model ever
+ * chooses it (load-tools, memory.schema MemorySource).
+ */
+export const createMemoryTools = (source: MemorySource) => ({
   [TOOL_NAMES.memory_recall]: tool({
     description: "Open one note from the listing, whole.",
     inputSchema: z.object({
@@ -65,32 +71,32 @@ export const createMemoryTools = () => ({
           replaces: z
             .number()
             .int()
-            .nullable()
+            .nullish()
             .describe(
               "The id of the fact this replaces — from this note as handed back here or by `memory_recall`. Null if this is new. A fact that stopped being true is replaced rather than deleted, and so is a note saying the same thing twice: replacing keeps what changed on the record, deleting does not.",
             ),
           alwaysLoad: z
             .boolean()
-            .nullable()
+            .nullish()
             .describe(
               `True carries this line into every call's instructions without opening its note — for what to call them, their language and register, a standing rule. At most ${ALWAYS_LOADED_MAX}. Null leaves it; false makes a carried line an ordinary fact.`,
             ),
         })
         .array()
-        .nullable()
+        .nullish()
         .describe(
           "What to write under this note. Send everything that came up at once: one call is one pause in the conversation, three calls are three. Null when only naming it.",
         ),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           `One line saying what this note is about, not what it currently says. Give it for a new note, or when the line no longer fits. Null leaves it; ${MEMORY_ALWAYS_LISTED.join(" and ")} keep their own line.`,
         ),
       aliases: z
         .string()
         .array()
-        .nullable()
+        .nullish()
         .describe(
           'What the user calls this note out loud, in the language they say it — the words they would use to ask for it, not the facts inside. A note at people/yuri might be "Yuri" and "my wife". Replaces the set it has, so send the whole set. Null leaves it.',
         ),
@@ -127,7 +133,7 @@ export const createMemoryTools = () => ({
               facts,
             };
 
-      const write = await writeNotes([filed]);
+      const write = await writeNotes([filed], source);
 
       // The write already succeeded; what follows are requests, not failures.
       // A path filed elsewhere must be said, or the model reports it saved where it asked.
@@ -240,9 +246,10 @@ export const botRememberTool = tool({
     // A path outside the convention goes to inbox, as it does for the call
     const filed = known || isMemoryPath(said) ? (known ?? said) : MEMORY_INBOX;
 
-    await writeNotes([
-      { path: filed, facts: written.map((text) => ({ text })) },
-    ]);
+    await writeNotes(
+      [{ path: filed, facts: written.map((text) => ({ text })) }],
+      "bot",
+    );
 
     // A write filed elsewhere must be said, or the report claims the wrong place
     return {

package/features/ai/tools/studio.tool.ts

@@ -118,7 +118,7 @@ const imageTool = async (): Promise<StudioTool | null> => {
         ),
       aspectRatio: z
         .enum(RATIOS)
-        .nullable()
+        .nullish()
         .describe("Aspect ratio. Null for square."),
     }),
     execute: async ({ prompt, aspectRatio }, { sandbox, abortSignal }) => {
@@ -161,11 +161,11 @@ const speechTool = async (): Promise<StudioTool | null> => {
         ),
       voice: z
         .string()
-        .nullable()
+        .nullish()
         .describe("A voice name the provider knows. Null for its default."),
       instructions: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           'How to read it — "slowly", "warm", "like a news anchor". Null for plain.',
         ),
@@ -259,14 +259,14 @@ const videoTool = async (): Promise<StudioTool | null> => {
         ),
       aspectRatio: z
         .enum(["16:9", "9:16"])
-        .nullable()
+        .nullish()
         .describe("Aspect ratio. Null for 16:9."),
       seconds: z
         .number()
         .int()
         .min(2)
         .max(10)
-        .nullable()
+        .nullish()
         .describe(
           "Length in seconds, 2 to 10. Null for the provider's default.",
         ),

package/features/ai/tools/tool-name.ts

@@ -29,6 +29,8 @@ export const TOOL_NAMES = {
   end_call: "end_call",
 
   tidy_done: "tidy_done",
+
+  update_notes: "update_notes",
 } as const;
 
 /**

package/features/ai/tools/workspace.tool.ts

@@ -3,7 +3,7 @@ import { type ToolSet, tool } from "ai";
 import z from "zod";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { writeRefusal } from "@/features/workspace/workspace";
-import type { Sandbox } from "@/lib/sandbox";
+import { EXEC_TIMEOUT_MS, type Sandbox } from "@/lib/sandbox";
 
 /**
  * Shell access, plus `write_file` for bots: multi-line files through a
@@ -15,6 +15,8 @@ export const createWorkspaceTools = (
     write: boolean;
     /** Per-run environment for `bash` (a job's browser session). */
     env?: Record<string, string>;
+    /** Attach the shell guide to this run's first `bash` result (bots only). */
+    guide?: boolean;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -23,20 +25,30 @@ export const createWorkspaceTools = (
     return r && !r.startsWith("..") ? r : p;
   };
 
+  // The tool set is built per run, so one guide per run lives in this closure.
+  let owed = options.guide === true;
+
   const bash = tool({
     description: "Run a bash command.",
     inputSchema: z.object({
       command: z.string(),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           "One short line for the user: what this command does and why. Shown on their screen while it runs — not a restatement of the command.",
         ),
     }),
     // The only tool here long-running enough to be cancelled.
-    execute: ({ command }, { abortSignal }) =>
-      sandbox.exec(command, { signal: abortSignal, env: options.env }),
+    execute: async ({ command }, { abortSignal }) => {
+      const result = await sandbox.exec(command, {
+        signal: abortSignal,
+        env: options.env,
+      });
+      if (!owed) return result;
+      owed = false;
+      return { ...result, guide: SHELL_GUIDE };
+    },
   });
 
   if (!options.write) return { [TOOL_NAMES.bash]: bash };
@@ -53,7 +65,7 @@ export const createWorkspaceTools = (
       content: z.string(),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           "One short line for the user: what this file is. Shown on their screen next to the path.",
         ),
@@ -69,3 +81,19 @@ export const createWorkspaceTools = (
 
   return { [TOOL_NAMES.bash]: bash, [TOOL_NAMES.write_file]: writeFile };
 };
+
+/**
+ * How this shell differs from a terminal, attached to a run's first `bash`
+ * result and never again. Each line is a way a job is lost for minutes and
+ * none can be found out from a command's output: state that silently does not
+ * carry, a question nobody will answer, a variable that was removed rather
+ * than never set. What this machine *has* is not here — that decides the first
+ * command, so it is in the prompt (prompts/bot.prompt environment).
+ */
+const SHELL_GUIDE = `## The shell here
+
+Every command is a new shell: \`cd\`, exported variables and an activated venv are gone by the next one — chain what depends on the last step into a single command.
+
+Nothing is watching it. A command that stops to ask never gets an answer and is killed after ${EXEC_TIMEOUT_MS / 1000}s, so pass the flag that skips the question (\`-y\`, \`--yes\`, \`--no-input\`), and send anything genuinely long to the background with its output redirected to a file.
+
+Keys are not in the environment: every variable named like a key, a token or a secret is removed before the shell starts. An empty one is not an unset one — say which it was, and ask for what a command needs.`;

package/features/bot/bot.action.ts

@@ -4,11 +4,24 @@ import { z } from "zod";
 import { textModelProviderSchema } from "@/features/ai/model.schema";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
-import { createBot, deleteBot, findBot, updateBot } from "./bot.query";
-import { answerTask, cancelTask, removeTask, startTask } from "./bot.runner";
+import {
+  clearBotNote,
+  createBot,
+  deleteBot,
+  findBot,
+  updateBot,
+  writeBotNotesOn,
+} from "./bot.query";
+import {
+  answerTask,
+  cancelTask,
+  removeFinishedTasks,
+  removeTask,
+  startTask,
+} from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
 import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { deleteFinishedTasks, markReported, resolveTask } from "./task.query";
+import { markReported, resolveTask } from "./task.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -67,6 +80,20 @@ export const deleteBotAction = serverAction(async (name: string) => {
   if (!(await deleteBot(name))) publicError("Bot not found");
 });
 
+/**
+ * Throws away what a bot wrote about itself. The only human touch on notes:
+ * they are never edited here, because a line the user typed would come back
+ * rewritten by the bot's next report.
+ */
+export const clearBotNoteAction = serverAction(async (name: string) => {
+  await clearBotNote(name);
+});
+
+/** Switched off, no bot writes to its own instructions and none is shown one. What is already written stays. */
+export const setBotNotesOnAction = serverAction(async (on: unknown) => {
+  await writeBotNotesOn(on === true);
+});
+
 // Tasks are opened by the `delegate` tool during a call, or here when the user
 // hands one over from the screen. Each returns at once, the run itself continues
 // in bot.runner behind `after()`.
@@ -126,5 +153,5 @@ export const deleteTaskAction = serverAction(async (id: string) => {
 
 /** Empties the log of what is over. Running and waiting jobs are not touched. */
 export const clearFinishedTasksAction = serverAction(async () => {
-  return { removed: await deleteFinishedTasks() };
+  return { removed: await removeFinishedTasks() };
 });

package/features/bot/bot.notes.ts

@@ -0,0 +1,120 @@
+import {
+  generateText,
+  hasToolCall,
+  type LanguageModel,
+  stepCountIs,
+  tool,
+} from "ai";
+import * as z from "zod";
+import { BOT_NOTES } from "@/config";
+import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import { logger } from "@/lib/logger";
+import { createKeyedLock } from "@/lib/queue";
+import { readBotNote, writeBotNote } from "./bot.query";
+
+/**
+ * Keeping a bot's own notes — the block of instructions it writes to itself, carried into
+ * every job of its own (ai/prompts/bot.prompt).
+ *
+ * The bot never writes the block. It says what it wants changed, in its own words, on
+ * `report` (ai/tools/bot.tool `notes`), and this rewrites the block from that. Two models
+ * because they are two jobs: a bot that has just finished work edits around the work, while
+ * a model handed one document and three change requests does what it was handed. Same model
+ * the job ran on, no system prompt, one tool, forced.
+ *
+ * Serialized per bot, which is the whole of the concurrency story: two jobs of one bot
+ * finishing together queue, and the second reads the block the first wrote.
+ */
+
+/** One bot at a time. Without it two passes read the same block and one of them is lost. */
+const lane = createKeyedLock();
+
+/** One call is the whole job; the rest is headroom for a rejected argument list. */
+const MAX_STEPS = 3;
+
+/** No request, no pass: a job that taught nothing must not cost a model call. */
+export const hasNotesRequest = (want: string | null): boolean =>
+  Boolean(want?.trim());
+
+export type KeepNotesInput = {
+  /** The bot whose notes these are; DEFAULT_BOT keeps them like any other. */
+  bot: string;
+  /** The model the job itself ran on (bot.run resolveModel). */
+  model: LanguageModel;
+  /** What the bot asked for, in its own words (ai/tools/bot.tool `notes`). */
+  want: string;
+  signal?: AbortSignal;
+};
+
+/**
+ * Applies one job's request. Resolves to the block as it now stands — and to what it was
+ * when the pass could not run: notes are never worth failing a job that already reported.
+ */
+export async function keepNotes(input: KeepNotesInput): Promise<string | null> {
+  return lane(input.bot, async () => {
+    const current = await readBotNote(input.bot);
+    let kept = current;
+
+    try {
+      await generateText({
+        model: input.model,
+        messages: [{ role: "user", content: briefing(current, input.want) }],
+        abortSignal: input.signal,
+        tools: {
+          [TOOL_NAMES.update_notes]: tool({
+            description: "Hand back the updated prompt.",
+            inputSchema: z.object({
+              prompt: z
+                .string()
+                .max(BOT_NOTES.chars)
+                .describe(
+                  `The whole prompt as it should now read, at most ${BOT_NOTES.chars} characters.`,
+                ),
+            }),
+            execute: async ({ prompt }) => {
+              await writeBotNote(input.bot, prompt);
+              kept = prompt.trim() || null;
+              return "Saved.";
+            },
+          }),
+        },
+        toolChoice: "required",
+        stopWhen: [
+          stepCountIs(MAX_STEPS),
+          hasToolCall(TOOL_NAMES.update_notes),
+        ],
+      });
+    } catch (cause) {
+      // Never the job's problem: its report is already handed back.
+      logger.warn(`notes pass for ${input.bot} failed: ${cause}`);
+    }
+    return kept;
+  });
+}
+
+/**
+ * The whole instruction, as one user turn. No system prompt: there is one document, three
+ * change requests, and one thing to do with them. A persona above that only invites the
+ * model to have views about the worker instead of editing the text it was handed.
+ */
+function briefing(current: string | null, want: string): string {
+  return `You keep one worker's notes. It is an agent with a shell on this machine; the notes are its own, read at the start of every job it runs and by nobody else. They hold what this machine has taught it — the command that works here, the flag without which something fails, the tool this platform does not have. Write what the worker found, never what it proposed.
+
+Four things do not belong, however true today: what is in a folder right now, what a job produced, anything about the person the work is for, and how to satisfy the worker's own tools (\`report\`, \`write_file\`, \`bash\` — those belong to the app it runs inside and change with it). A program *on the machine* is the opposite and does belong.
+
+Nor does how the worker should behave. Whoever owns it writes that separately and it outranks these, so a note about manner or language is either already said or about to be overruled.
+
+The change is applied to what is already there, not written over it. Say the notes read \`Tests here run with npm.\` and then \`Chromium needs --no-sandbox or it exits.\` The worker asks for the npm line to be corrected to pnpm: both lines come back, the first now reading \`Tests here run with pnpm.\` and the second word for word as it was. Added, corrected or dropped is one line moving; everything the request did not name is untouched.
+
+${current ? "The notes as they stand:" : "There are no notes yet — the fence below is empty because nothing has been written, not because the notes say so."}
+
+\`\`\`
+${current ?? ""}
+\`\`\`
+
+The worker asks for this change:
+
+${want.trim()}
+
+Hand back the whole thing as it should now read, keeping what the request does not touch. Only what belongs inside the fence, never a word about it, and nothing at all when the request holds nothing that belongs. At most ${BOT_NOTES.chars} characters, which is a ceiling and not a target.`;
+}

package/features/bot/bot.query.ts

@@ -1,16 +1,21 @@
 import { eq, inArray, sql } from "drizzle-orm";
+import { BOT_NOTES } from "@/config";
 import { database } from "@/database/db";
 import {
   botMcpToolTable,
+  botNoteTable,
   botTable,
   mcpToolTable,
   taskTable,
 } from "@/database/tables";
 import type { TextModelProviderId } from "@/features/ai/model.schema";
+import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
+  BOT_NOTES_KEY,
   type BotForm,
   type BotIcon,
   DEFAULT_BOT,
+  isBotNotesOn,
   type JobBot,
   type PinnedTool,
   pickedModel,
@@ -61,7 +66,7 @@ export async function findJobBot(name: string): Promise<JobBot | null> {
 
 /** Bots with their pinned tools and token totals: a set of queries plus grouping, not a join. */
 export async function findAllBots() {
-  const [bots, pins, spent] = await Promise.all([
+  const [bots, pins, spent, notes] = await Promise.all([
     database.select().from(botTable).orderBy(botTable.createdAt),
     database
       .select({
@@ -83,6 +88,7 @@ export async function findAllBots() {
       })
       .from(taskTable)
       .groupBy(taskTable.bot),
+    database.select().from(botNoteTable),
   ]);
 
   const byBot = new Map<string, PinnedTool[]>();
@@ -104,14 +110,61 @@ export async function findAllBots() {
         : [[row.bot, new Date(Number(row.lastJobAt) * 1000)] as const],
     ),
   );
+  const noteOf = new Map(notes.map((row) => [row.bot, row]));
   return bots.map((bot) => ({
     ...bot,
     tools: byBot.get(bot.name) ?? [],
     tokens: tokensOf.get(bot.name) ?? { input: 0, output: 0 },
     lastJobAt: lastJobOf.get(bot.name) ?? null,
+    note: noteOf.get(bot.name)?.text ?? null,
+    noteAt: noteOf.get(bot.name)?.updatedAt ?? null,
   }));
 }
 
+// A bot's own notes. Nothing here belongs to a job: the row survives every job
+// the bot runs and is read back into its next prompt (ai/prompts/bot.prompt).
+
+/** What this bot has written to itself. Keyed by name, so DEFAULT_BOT has one too. */
+export async function readBotNote(bot: string): Promise<string | null> {
+  const [row] = await database
+    .select({ text: botNoteTable.text })
+    .from(botNoteTable)
+    .where(eq(botNoteTable.bot, bot));
+  return row?.text ?? null;
+}
+
+/**
+ * The whole block, as the pass rewrote it (bot.notes). Cut rather than refused: the schema
+ * already caps it, and a run that gets this far has handed its report back. Empty clears it.
+ */
+export async function writeBotNote(bot: string, text: string): Promise<void> {
+  const next = text.trim().slice(0, BOT_NOTES.chars).trim();
+  if (!next) return clearBotNote(bot);
+
+  const updatedAt = new Date();
+  await database
+    .insert(botNoteTable)
+    .values({ bot, text: next, updatedAt })
+    .onConflictDoUpdate({
+      target: botNoteTable.bot,
+      set: { text: next, updatedAt },
+    });
+}
+
+/** Whether any bot keeps its own instructions at all (bot.schema BOT_NOTES_KEY). */
+export async function readBotNotesOn(): Promise<boolean> {
+  return isBotNotesOn(await readConfig(BOT_NOTES_KEY));
+}
+
+export async function writeBotNotesOn(on: boolean): Promise<void> {
+  await writeConfig(BOT_NOTES_KEY, on ? "on" : "off");
+}
+
+/** The one thing the user does to notes: throw them away when a bot has learned something wrong. */
+export async function clearBotNote(bot: string): Promise<void> {
+  await database.delete(botNoteTable).where(eq(botNoteTable.bot, bot));
+}
+
 export async function findBot(name: string) {
   const [bot] = await database
     .select()
@@ -175,5 +228,7 @@ export async function deleteBot(name: string) {
     .delete(botTable)
     .where(eq(botTable.name, name))
     .returning({ name: botTable.name });
+  // Notes are keyed by name with no foreign key, so nothing cascades for them.
+  await clearBotNote(name);
   return removed.length > 0;
 }

package/features/bot/bot.run.ts

@@ -30,13 +30,18 @@ import {
   NO_TOKENS,
   type TokenUsage,
 } from "@/features/bot/bot.schema";
-import { closeJobShell } from "@/features/workspace/workspace";
+import {
+  closeJobShell,
+  openBotFolder,
+  openJobScratch,
+} from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { publicError } from "@/lib/public-error";
 import { estimateTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
-import { findJobBot } from "./bot.query";
-import { optionsOf, toolLine } from "./task.query";
+import { hasNotesRequest, keepNotes } from "./bot.notes";
+import { findJobBot, readBotNotesOn } from "./bot.query";
+import { findTask, optionsOf, toolLine } from "./task.query";
 
 /**
  * The bot loop behind `delegate`: one model with its own prompt, tools and
@@ -154,11 +159,23 @@ export async function runBot(
 
   // Tools are built on the model: web search runs on this bot's model (load-tools).
   const model = await resolveModel(bot);
+  // One folder per job, not per bot: bots borrowed with `ask_bot` work inside
+  // the same job and share its material (workspace.ts jobScratch).
+  const [scratch, own] = await Promise.all([
+    options.taskId
+      ? openJobScratch(
+          options.taskId,
+          (await findTask(options.taskId))?.label ?? "job",
+        )
+      : null,
+    openBotFolder(name),
+  ]);
   const [prompt, tools] = await Promise.all([
     loadBotPrompt(
       name,
       bot.systemPrompt,
       "askedBy" in input ? input.askedBy : null,
+      { scratch, own },
     ),
     loadTools({
       target: "bot",
@@ -286,6 +303,8 @@ export async function runBot(
   let asked: { id: string; question: string; options: string[] } | null = null;
   /** The report (bot.tool reportSpec). */
   let reported: { text: string; complete: boolean } | null = null;
+  /** What the bot wants changed about its own instructions (bot.tool `notes`); applied after the report. */
+  let wants: string | null = null;
 
   // An abort ends the stream without a finish; release any waiting take.
   options.signal?.addEventListener("abort", () => steps.end(), { once: true });
@@ -332,6 +351,7 @@ export async function runBot(
               text: String(args.result ?? "").trim(),
               complete: args.complete !== false,
             };
+            wants = notesRequestOf(part.input);
           }
           await emit({
             type: "tool",
@@ -401,6 +421,16 @@ export async function runBot(
 
   if (reported) {
     await emit({ type: "report", ...reported });
+    // After the report, never before, and only when the bot asked for something:
+    // a job that changed nothing about this machine must not cost a model call.
+    if (hasNotesRequest(wants) && (await readBotNotesOn())) {
+      await keepNotes({
+        bot: name,
+        model: model.model,
+        want: wants as string,
+        signal: options.signal,
+      });
+    }
     return;
   }
 
@@ -422,6 +452,16 @@ const reportAccepted_ = ({ steps }: { steps: StepResult<ToolSet>[] }) =>
         result.toolName === TOOL_NAMES.report && reportAccepted(result.output),
     ) ?? false;
 
+/** A provider that cannot send null in a string field writes the word instead. */
+const NO_NOTES = new Set(["null", "none", "n/a", "-", "없음"]);
+
+/** `report`'s `notes` as the pass takes it. */
+function notesRequestOf(input: unknown): string | null {
+  const said = (input as { notes?: unknown })?.notes;
+  const text = typeof said === "string" ? said.trim() : "";
+  return text && !NO_NOTES.has(text.toLowerCase()) ? text : null;
+}
+
 /**
  * The step before the cap is narrowed to `report` and required to call it,
  * so a run out of budget ends with something a person can act on.