thursday-agent 0.1.2 → 0.2.0

package/docs/how-it-works.md

@@ -0,0 +1,59 @@
+# How it works
+
+The README says what Thursday is. This says what each part may touch, so you can guess what will happen before you say it.
+
+## The call
+
+A call is a session with a realtime speech model — OpenAI Realtime or xAI Grok Voice, whichever key you gave. Audio in, audio out, interruptions and all. The model hears a prompt assembled the moment the line opens: who she is, what she remembers about you, which bots exist, what was said on the last calls.
+
+She holds three things and nothing else:
+
+- **Memory.** A folder of notes about you. She reads a note before answering out of it and writes the moment something worth keeping comes up — one fact per line, dates as dates. A rule you lay down ("answer in Korean", "keep it short") is carried into every call.
+- **One command.** A shell, for the things that take a second: open a file, play something, look at what is in a folder. One command is something she does, not a job she hands over.
+- **The roster.** The bots, by name, and what each is for.
+
+Everything else — anything that takes more than a few seconds — she hands to a bot with `delegate` and keeps talking. That is deliberate: the call must never go silent, and a speech model that runs a browser would be silent for minutes.
+
+When a job comes back, it arrives as a system note, not as you speaking. She tells you in one sentence, in her own words. A file the job made opens on your screen by itself; a question the job asks becomes buttons on screen and words in your ear.
+
+## Bots
+
+A bot is a text model — any of OpenAI, Anthropic, Google, xAI, or whatever the Vercel AI Gateway carries — with the whole machine:
+
+- a **shell** in a workspace folder, with no pager and no secrets in its environment
+- a **real browser** (Chromium through Playwright), headless until a sign-in or something you should see, and able to attach to the Chrome you already use
+- the **filesystem**, read anywhere, written only inside the workspace and where you pointed it
+- **skills** — written-down methods it reads before starting: the browser, this Mac, building a page, finding and writing skills
+- **MCP servers** you connected, searched by name and called by schema, with OAuth handled
+- a **studio** of image, video, speech and transcription models
+- **each other**: a bot hands a part of its job to the bot that exists for it, and folds the answer into its own report
+
+A job ends in the thing that was asked for — the account made, the page built, the comparison in a table — and a report, written to be heard, because she reads it out loud. Anything that does not fit in a few lines is a file under `artifacts/`, and the report names it.
+
+What only you can give — a password, a one-time code, a passkey, a decision between two real options — stops the job at that point. The bot sets it up one action away, asks, and continues when the answer comes.
+
+Three bots come with the app, split by temperament: **Jarvis** plans a job, hands parts to whoever fits and does the rest; **Navigator** goes and looks; **Scribe** writes. Make more in settings: a name, a sentence about what it is for, optionally a model and a few pinned tools. The sentence is what she reads when deciding who gets the job.
+
+## Jobs outlive the call
+
+A job runs on the server. It is not in the tab, and it does not stop when you hang up. Every step — the request, each tool call, what came back, the report — is written as a row, and the screen is a projection of those rows. When you come back, the jobs that finished are waiting, and she tells you about them on the next call, or rings you if you turned that on.
+
+A job that stopped to ask, or ran out of its step budget, is resumed from where it stopped: the same thread, with your answer appended. A long thread is compacted — the model summarizes what happened so far and continues from the summary.
+
+## Memory is a folder
+
+Memory is plain notes on your disk, in the data folder (`~/.thursday` when installed with `npx`, the checkout otherwise). Each note is a topic — `profile`, `preferences`, `people/…`, and whatever she creates. A few are `alwaysLoad` and travel into every call: your name, your language, how you like to be addressed, the rules you gave her.
+
+You can open any note from settings and read exactly what she knows. When the listing gets long she says so in a lull, puts a note on your screen and forgets only what you name.
+
+Writing mid-conversation catches what she noticed; it misses what only reads back as important afterwards. So when a call ends, a text model re-reads the most recent turns and reconciles the notes with them — correcting what changed, adding what was said in passing. Calls are stamped as they are read, so a backlog of short calls collapses into one pass rather than one per call.
+
+Bots read memory but do not write it. What a bot learns goes into its report; whether it is worth keeping is her call, with you.
+
+## What is not here
+
+- **No cloud.** The server is the one on your machine; keys are stored locally and sent only to the provider you chose.
+- **No account.** There is nothing to sign up for. There is also no login, which is why the server binds to `127.0.0.1` — see [SECURITY.md](../SECURITY.md).
+- **No prompt engineering on your side.** The prompts are assembled from your data on every session; the one thing you can add is an instruction to her, and one to each bot, in settings.
+
+For the code — which file owns what, and why — read [CLAUDE.md](../CLAUDE.md).

package/features/ai/load-tools.ts

@@ -1,11 +1,12 @@
-import { type ToolSet, tool } from "ai";
+import { asSchema, type ToolSet, tool } from "ai";
 import { formatDistanceToNowStrict } from "date-fns";
+import { IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
-import { tidying } from "@/features/ai/prompts/prompt-helper";
+import { clockNow, tidying } from "@/features/ai/prompts/prompt-helper";
 import {
   askThursdayTool,
+  createReportTool,
   delegateSpec,
-  reportTool,
   taskSpec,
 } from "@/features/ai/tools/bot.tool";
 import { CALL_TOOLS } from "@/features/ai/tools/call.tool";
@@ -19,12 +20,15 @@ import { createSkillTools } from "@/features/ai/tools/skills.tool";
 import { tidyDoneTool } from "@/features/ai/tools/tidy.tool";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { createWorkspaceTools } from "@/features/ai/tools/workspace.tool";
+import { readBotNotesOn } from "@/features/bot/bot.query";
 import { taskActivity } from "@/features/bot/bot.schema";
 import { listNoteIndex } from "@/features/memory/memory.query";
 import { loadSkills } from "@/features/skills/skills.discover";
 import { readCallSkillsOn } from "@/features/thursday/thursday.query";
 import { jobShellEnv, openWorkspace } from "@/features/workspace/workspace";
 import { toDate } from "@/lib/date-like";
+import { logger } from "@/lib/logger";
+import { estimateTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
 import { resolveSearchModel } from "./model";
 
@@ -109,12 +113,16 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
                 note: "The text in `answer` was not passed on — `status` only reads. Send it again as `answer` if the bot is meant to hear it.",
               }
             : {};
+          // The clock, because the one in the instructions is from when the call
+          // opened and a call can run for hours; `since` is measured against this.
+          const now = { now: clockNow() };
           // A named job comes back whole; the list clips outcomes, and the model pads a clipped report
           if (task) {
             const found = await resolveTask(task);
             const one = found;
             if (!one) return await noSuchJob(task);
             return {
+              ...now,
               ...dropped,
               label: one.label,
               bot: one.bot,
@@ -132,6 +140,7 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           // No threads — only as much as is worth reading out: what it is
           // asking, the one line of what it is doing, or how it ended
           return {
+            ...now,
             ...dropped,
             tasks: tasks.map((task) => ({
               label: task.label,
@@ -190,8 +199,44 @@ async function noSuchJob(ref: string): Promise<string> {
   return `There is no job called "${ref}". The latest are: ${names}. Call again with one of those names.`;
 }
 
+/**
+ * What the set costs the model, beside the prompt's own line (prompts/prompt-helper
+ * logPromptSize). Descriptions and schemas are both counted because both are sent
+ * on every step. No budget here: the set is decided by the code, except for the MCP
+ * tools a bot is pinned to — those show up by name.
+ */
+async function logToolSize(target: ToolTarget, tools: ToolSet): Promise<void> {
+  const rows: { name: string; tokens: number }[] = [];
+  for (const [name, held] of Object.entries(tools)) {
+    const schema = await asSchema(held.inputSchema).jsonSchema;
+    // A description may be a function of the call's context; only a fixed one is counted
+    const said = typeof held.description === "string" ? held.description : "";
+    rows.push({
+      name,
+      tokens: estimateTokens(said) + estimateTokens(JSON.stringify(schema)),
+    });
+  }
+  rows.sort((a, b) => b.tokens - a.tokens);
+  const total = rows.reduce((sum, row) => sum + row.tokens, 0);
+  logger.debug(
+    `${target} tools ${total} tokens over ${rows.length} — ${rows
+      .map((row) => `${row.name} ${row.tokens}`)
+      .join(", ")}`,
+  );
+}
+
 export async function loadTools(run: ToolRun): Promise<ToolSet> {
-  const memory = createMemoryTools();
+  const tools = await buildTools(run);
+  // Measured only where the line would be printed: the schemas have to be built
+  // to be counted, and unlike a prompt this set does not grow with use.
+  if (IS_DEV) await logToolSize(run.target, tools);
+  return tools;
+}
+
+async function buildTools(run: ToolRun): Promise<ToolSet> {
+  // The runtime is the hand: the call as the user talks, the pass that reads
+  // calls back, a bot mid-job (memory.tool botRememberTool records its own).
+  const memory = createMemoryTools(run.target === "tidy" ? "tidy" : "call");
 
   if (run.target === "tidy") {
     // Reading calls back (memory/memory.tidy): the one runtime besides the call
@@ -242,11 +287,16 @@ export async function loadTools(run: ToolRun): Promise<ToolSet> {
     ...createWorkspaceTools(sandbox, {
       write: true,
       env: jobShellEnv(run.taskId),
+      // What the shell is like and what this machine has, on the first command
+      // of the run only (workspace.tool shellGuide). The call gets no guide:
+      // one command is a glance, not a job to plan around
+      guide: true,
     }),
     // Pinned tools come with schemas; the rest sit behind `tool_search`, absent when nothing is left to find (mcp.tool)
     ...(await createMcpTools(run.bot, sandbox)),
     ...createSkillTools({ sandbox, skills }),
     [TOOL_NAMES.ask_thursday]: askThursdayTool,
-    [TOOL_NAMES.report]: reportTool,
+    // No field for its own instructions when nobody keeps them (bot.schema BOT_NOTES_KEY)
+    [TOOL_NAMES.report]: createReportTool(await readBotNotesOn()),
   };
 }

package/features/ai/prompts/bot.prompt.ts

@@ -1,6 +1,10 @@
-import { BOT_RUN, PATHS } from "@/config";
+import { BOT_NOTES, BOT_RUN, PATHS } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import { listJobBots } from "@/features/bot/bot.query";
+import {
+  listJobBots,
+  readBotNote,
+  readBotNotesOn,
+} from "@/features/bot/bot.query";
 import type { JobBot } from "@/features/bot/bot.schema";
 import { findPinnedTools } from "@/features/connectors/mcp.query";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
@@ -16,13 +20,18 @@ import {
   loadSkills,
   type SkillMetadata,
 } from "@/features/skills/skills.discover";
-import { openWorkspace } from "@/features/workspace/workspace";
+import {
+  type MachineTools,
+  openWorkspace,
+  readMachineTools,
+} from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { clip } from "@/lib/utils";
 import { listConnectedToolNames } from "../tools/connected";
 import {
   carriedLines,
   type LoadedPrompt,
+  logPromptSize,
   mcpToolLines,
   noteLines,
   nowLine,
@@ -44,31 +53,47 @@ export async function loadBotPrompt(
   self: string,
   persona?: string | null,
   askedBy?: string | null,
+  /** The two folders that are this run's rather than the user's (bot.run). */
+  folders?: { scratch: string | null; own: string },
 ): Promise<LoadedPrompt> {
   const sandbox = await openWorkspace();
   const name = self.trim();
-  const [skills, index, carried, mcpTools, pinned, allBots] = await Promise.all(
-    [
-      loadSkills(sandbox),
-      listNoteIndex(),
-      listAlwaysLoaded(),
-      // User-connected servers and the app's studio in one list (tools/connected)
-      listConnectedToolNames(),
-      // MCP tools this bot already holds; dropped from the listing below
-      findPinnedTools(name),
-      listJobBots(),
-    ],
-  );
+  const [
+    skills,
+    index,
+    carried,
+    mcpTools,
+    pinned,
+    allBots,
+    ownNote,
+    notesOn,
+    machine,
+  ] = await Promise.all([
+    loadSkills(sandbox),
+    listNoteIndex(),
+    listAlwaysLoaded(),
+    // User-connected servers and the app's studio in one list (tools/connected)
+    listConnectedToolNames(),
+    // MCP tools this bot already holds; dropped from the listing below
+    findPinnedTools(name),
+    listJobBots(),
+    // What this bot left itself; kept by the pass that runs after a job (bot.notes)
+    readBotNote(name),
+    readBotNotesOn(),
+    // One `command -v` sweep; what is here decides the first command (environment)
+    readMachineTools(sandbox),
+  ]);
 
   // Drop self so a bot cannot call itself; a borrowed bot has no roster at all (bot.run MAX_DEPTH)
   const peers = askedBy ? [] : allBots.filter((bot) => bot.name !== name);
 
   const text = [
-    askedBy ? borrowedIdentity(askedBy) : identity(),
+    askedBy ? borrowedIdentity(name, askedBy) : identity(name),
     memory(index, carried),
+    notesOn ? notes(ownNote) : "",
     connectedTools(mcpTools, pinned),
     methods(skills),
-    environment(sandbox.cwd),
+    environment(sandbox.cwd, machine, folders),
     roster(peers),
     askedBy ? askingBack(askedBy) : ASKING,
     askedBy ? handingUp(askedBy) : FINISHING,
@@ -78,6 +103,7 @@ export async function loadBotPrompt(
     .filter(Boolean)
     .join("\n\n");
 
+  logPromptSize("bot", text);
   logger.debug(`bot prompt\n${text}`);
 
   return {
@@ -88,18 +114,19 @@ export async function loadBotPrompt(
 }
 
 /** Who the bot is, what machine it is on, and that guesses are not results. */
-function identity(): string {
+function identity(name: string): string {
   return [
-    `You are a worker. Thursday handed you a job while she keeps talking to the user; you are not in that conversation and never speak to the user directly. ${nowLine()}`,
+    // Named, because the owner's prompt may not name it and its own instructions are addressed to it
+    `You are ${name}, a worker. Thursday handed you a job while she keeps talking to the user — they speak to her and to nobody else, and what she reads them out of your report is the only part of this that reaches them. You are not in that conversation and never address the user. This thread is drawn on their screen while you work, though: not written to them, but not private either. ${nowLine()}`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
 }
 
 /** The borrowed seat: above it is the borrowing bot, not Thursday. */
-function borrowedIdentity(askedBy: string): string {
+function borrowedIdentity(name: string, askedBy: string): string {
   return [
-    `You are a worker. ${askedBy} is holding a job Thursday handed them and has handed one part of it to you. You never speak to the user: ${askedBy} reports, and what you hand back goes into their report as-is. ${nowLine()}`,
+    `You are ${name}, a worker. ${askedBy} is holding a job Thursday handed them and has handed one part of it to you. The user speaks to Thursday and to nobody else; you never address them, and what you hand back goes into ${askedBy}'s report as-is. This thread is drawn on their screen while you work: not written to them, but not private either. ${nowLine()}`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
@@ -107,7 +134,7 @@ function borrowedIdentity(askedBy: string): string {
 
 const MACHINE = `**You are on a real computer — the user's own.** You have a shell and a filesystem, and the job is done, not described: where there is no tool for something, write one — in \`node\` unless they asked for another language, the runtime this app itself runs on. Reach for \`${TOOL_NAMES.bash}\` before concluding that something cannot be done, but after the roster, not instead of it: a script you write to do another bot's job is the long way round.
 
-**What is missing gets installed.** Inside the workspace, freely; onto the machine itself — \`python3\`, a \`brew\` package — once they say yes, so ask. What is already there is nobody's question.
+**What is missing gets installed**, onto the machine once they say yes. What is already there is nobody's question — Environment says what this machine has.
 
 **Bring back the thing itself** — their own machine, their own accounts, their own copy of whatever they sent you for — not a smaller safer version of it, and not a note on why you did not.`;
 
@@ -134,7 +161,9 @@ function memory(
 ): string {
   const head = `## Memory
 
-What the user's assistant knows about them — yours to read, and to add to when the work turns up something about them that outlives the job. What the job itself turned up goes in your report. It describes the user, not you: how they are named and spoken to is hers to use with them, not yours to borrow.`;
+What the user's assistant knows about them. Thursday keeps it as she talks with them, and everyone reads it.
+
+Yours to read, and to add to when the work turns up something about *them* that outlives the job; what the job itself turned up goes in your report. It describes the user, not you: how they are named and spoken to is hers to use with them, not yours to borrow. What you learn about this machine is not memory — that is your own instructions, below.`;
 
   const alreadyKnown = carried.length
     ? `Already known:
@@ -151,6 +180,24 @@ A topic not listed is one nobody knows anything about.`;
   return [head, alreadyKnown, listing].filter(Boolean).join("\n\n");
 }
 
+/**
+ * The bot's own notes, carried between jobs (database bot_note). Always drawn, empty or not,
+ * so a first job knows it has them. What belongs in them is on `report`, the only place a
+ * change can be asked for (tools/bot.tool); the chapter is what they are and that they last.
+ * The line about what goes in first shows only while they are empty — a standing instruction
+ * to write something turns every job into a note, and there is nothing to nudge once a bot
+ * has one. The count is here for the same reason: the room left is a fact, not a target.
+ */
+function notes(own: string | null): string {
+  return `## Your own instructions
+
+What you wrote to yourself on earlier jobs here, to get better at this machine. Only you read it, and it is the one thing that reaches your next job. What belongs in it is what working here is like — the command that turns out to be the right one, the flag it needs, the tool this platform does not have. Not what the user is like: that is Memory, above, and everyone reads that one.
+
+${own ?? "Empty. What usually goes in first is whatever you had to find out before you could start."}
+
+(${own?.length ?? 0}/${BOT_NOTES.chars} characters)`;
+}
+
 /**
  * Names only; schemas stay behind `tool_search`. Without the list the model cannot tell
  * "no such tool" from "not searched yet".
@@ -184,13 +231,35 @@ Written-down methods. When the job is one of these, read it with \`${TOOL_NAMES.
 ${skillLines(skills)}`;
 }
 
-/** Names the three workspace folders once; `write_file` refuses anything else (workspace.ts writeRefusal). */
-const environment = (cwd: string) => `## Environment
+/**
+ * The machine, then the workspace. What is installed is read as the prompt is
+ * assembled (workspace.ts readMachineTools) rather than left to the job to find
+ * out: a bot that has to check first spends a step on it, and one that guesses
+ * writes for a runtime that is not here. Naming what is absent does as much
+ * work as naming what is present — it is the half a model otherwise assumes.
+ * The three folders are named once; `write_file` refuses anything else
+ * (workspace.ts writeRefusal).
+ */
+const environment = (
+  cwd: string,
+  machine: MachineTools,
+  folders?: { scratch: string | null; own: string },
+) => `## Environment
 
 Current Cwd: ${cwd}
 Platform: ${process.platform}
+${machineLines(machine)}
+
+Read off this machine as the job opened, so it is current: reach for what is here instead of checking for it.
+
+Your workspace — \`${TOOL_NAMES.bash}\` runs here. Everything you write goes in one of these, and they are kept apart because what is in them lives for different lengths of time:
 
-Your workspace — \`${TOOL_NAMES.bash}\` runs here. Everything you write goes in one of three folders: \`${PATHS.artifacts}/\` (finished work the user opens), \`${PATHS.projects}/\` (code you build), \`${PATHS.scratch}/\` (everything in progress). Never the directory above — that is the app you run in; outside the workspace, only where the user pointed you.`;
+- \`${PATHS.artifacts}/\` — finished work the user opens, one entry per result. Theirs, and it stays.
+- \`${PATHS.projects}/\` — code you build, one folder each. It outlives this job, and a project's dependencies install inside it, never at the workspace root.
+- \`${folders?.scratch ?? PATHS.scratch}/\` — this job's working material. It goes when the job does, so nothing here is worth keeping.
+- \`${folders?.own ?? PATHS.bots}/\` — yours, across every job you run here. A script you wrote once and will want again, a table you built. Your own instructions can name what is in it.
+
+Never the directory above — that is the app you run in; outside the workspace, only where the user pointed you.`;
 
 /** Same roster the voice prompt shows, used the other way: which part of a held job is another bot's. */
 function roster(peers: JobBot[]): string {
@@ -200,6 +269,8 @@ function roster(peers: JobBot[]): string {
 
 ${peers.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}
 
+These lines were written for the user, who reads them on their own screen: where one says "you" it means them, not you.
+
 A part of your job another bot is for goes to \`${TOOL_NAMES.ask_bot}\`, because their tools and their practice are the reason they exist. What you build is made of what they bring back, so send for it before you build. A part you could finish in a couple of commands is yours; one that would take a run of its own is theirs. The job stays yours and you report; they see only your brief — not the call, not this thread.`;
 }
 
@@ -260,3 +331,27 @@ A detail that is not in the request may be here — a name, a number, which one
 
 ${lines.join("\n")}`;
 }
+
+/** One line per kind, absences included. Only a bot gets these: the call runs one command as a glance. */
+function machineLines(machine: MachineTools): string {
+  const line = (label: string, of: MachineTools["runtimes"]) =>
+    `${label}: ${of.found.length ? of.found.join(", ") : "none"}.${
+      of.missing.length ? ` Not here: ${of.missing.join(", ")}.` : ""
+    }`;
+  // Not a preference: openWorkspace writes the pnpm fence, and an `npm install`
+  // in a project here resolves against that rather than against the project
+  const fenced = machine.managers.found.includes("pnpm")
+    ? " Use pnpm, not npm — this workspace is fenced for it (`pnpm-workspace.yaml`, `.npmrc`)."
+    : "";
+  return [
+    line("Runtimes", machine.runtimes),
+    `${line("Package managers", machine.managers)}${fenced}`,
+    machine.browser === null
+      ? ""
+      : machine.browser
+        ? "Browser: installed."
+        : "Browser: not installed — `playwright-cli install-browser chromium` puts one there.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}

package/features/ai/prompts/memory-tidy.prompt.ts

@@ -13,7 +13,12 @@ import {
 } from "@/features/memory/memory.schema";
 import type { OwedTurn } from "@/features/thursday/thursday.query";
 import { logger } from "@/lib/logger";
-import { carriedLines, noteLines, nowLine } from "./prompt-helper";
+import {
+  carriedLines,
+  logPromptSize,
+  noteLines,
+  nowLine,
+} from "./prompt-helper";
 
 /**
  * Everything the read-back hears (features/memory/memory.tidy). One system text
@@ -39,6 +44,7 @@ export async function loadTidyPrompt(
   ]);
   const system = [identity(), memory(index, carried), pass()].join("\n\n");
   const user = [transcript(read), written(read.written)].join("\n\n");
+  logPromptSize("tidy", `${system}\n\n${user}`);
   logger.debug(`tidy prompt\n${system}\n\n${user}`);
   return { system, user };
 }

package/features/ai/prompts/prompt-helper.ts

@@ -1,5 +1,5 @@
 import { format, formatDistanceToNowStrict } from "date-fns";
-import { MEMORY_LISTING_TOKENS, PROMPT_LINE } from "@/config";
+import { MEMORY_LISTING_TOKENS, PROMPT_BUDGET, PROMPT_LINE } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
 import type {
@@ -9,7 +9,8 @@ import type {
 import { MANY_FACTS } from "@/features/memory/memory.schema";
 import type { SkillMetadata } from "@/features/skills/skills.discover";
 import { toDate } from "@/lib/date-like";
-import { estimateTokens } from "@/lib/tokens";
+import { logger } from "@/lib/logger";
+import { estimateTokens, sectionTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
 
 /**
@@ -26,12 +27,37 @@ export type LoadedPrompt = {
   opening: string | null;
 };
 
-/** `**Now**: 2026-09-02 (Wed) 15:41 Asia/Seoul` */
-export const nowLine = (now = new Date()) =>
-  `**Now**: ${format(now, "yyyy-MM-dd (EEE) HH:mm")} ${
+/**
+ * What one assembled prompt costs, said where it is assembled. The debug line is
+ * the whole breakdown; past PROMPT_BUDGET it is a warning naming the chapter
+ * carrying it, and that one is always a listing the user can act on — nothing
+ * else in the app would ever say a prompt had grown.
+ */
+export function logPromptSize(kind: string, text: string): void {
+  const parts = sectionTokens(text);
+  const total = parts.reduce((sum, part) => sum + part.tokens, 0);
+  logger.debug(
+    `${kind} prompt ${total} tokens — ${parts
+      .map((part) => `${part.name} ${part.tokens}`)
+      .join(", ")}`,
+  );
+  const biggest = parts[0];
+  if (total > PROMPT_BUDGET && biggest) {
+    logger.warn(
+      `${kind} prompt is ${total} tokens, over ${PROMPT_BUDGET}: ${biggest.name} carries ${biggest.tokens} of it. Every call and every job pays this.`,
+    );
+  }
+}
+
+/** `2026-09-02 (Wed) 15:41 Asia/Seoul` */
+export const clockNow = (now = new Date()) =>
+  `${format(now, "yyyy-MM-dd (EEE) HH:mm")} ${
     Intl.DateTimeFormat().resolvedOptions().timeZone
   }`;
 
+/** `**Now**: 2026-09-02 (Wed) 15:41 Asia/Seoul` */
+export const nowLine = (now = new Date()) => `**Now**: ${clockNow(now)}`;
+
 /** `4mo`, `12d`: short enough to read aloud. */
 function sinceLast(at: MemoryIndexEntry["lastSeenAt"]): string {
   const days = Math.floor((Date.now() - toDate(at).getTime()) / 86_400_000);

package/features/ai/prompts/thursday.prompt.ts

@@ -29,6 +29,7 @@ import { listConnectedToolNames } from "../tools/connected";
 import {
   carriedLines,
   type LoadedPrompt,
+  logPromptSize,
   mcpServerLines,
   noteLines,
   nowLine,
@@ -85,6 +86,7 @@ export async function loadThursdayPrompt(
     .filter(Boolean)
     .join("\n\n");
 
+  logPromptSize("thursday", text);
   logger.debug(`thursday prompt\n${text}`);
 
   return {

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

@@ -94,7 +94,7 @@ export const askThursdaySpec = {
     // joined string, and a schema rejection only loops. The reader takes arrays only (task.query optionsOf)
     options: z
       .union([z.string().array(), z.string()])
-      .nullable()
+      .nullish()
       .describe(
         'Only when there really are choices — two or three, each short, as an array: ["Signed in", "Not yet"]. Null for an open question.',
       ),
@@ -104,8 +104,11 @@ export const askThursdaySpec = {
 /**
  * The one way a run ends on its own terms; the loop is stopped by it (`hasToolCall`, bot.run).
  * `complete` cannot be inferred: a run out of steps and a finished run look the same from outside.
+ * `notes` is what the bot wants changed about its own instructions, in its own words — never
+ * the text itself. A bot that rewrites the whole thing here edits it around the job it was on
+ * and drops what that job was not about; a pass of its own writes it (features/bot/bot.notes).
  */
-export const reportSpec = {
+export const reportSpec = (notes: boolean) => ({
   name: TOOL_NAMES.report,
   description:
     "Hand back what the job produced. Calling this ends the job — nothing after it runs.",
@@ -120,8 +123,21 @@ export const reportSpec = {
       .describe(
         "True when the whole request is done. False when work is left over — the user is then asked whether to keep going, and `result` is what they decide on.",
       ),
+    ...(notes
+      ? {
+          notes: reportNotes,
+        }
+      : {}),
   }),
-};
+});
+
+/** Only attached while Settings > Bots keeps them (bot.schema BOT_NOTES_KEY). */
+const reportNotes = z
+  .string()
+  .nullish()
+  .describe(
+    "What should change in your own instructions before your next job here — something to add, something wrong to correct, something to drop. Your own words, any length; someone else writes it in. Nothing to say is the usual answer, and leaving it out costs nothing: they already say what they say.",
+  );
 
 /** The voice session's handle on a job already handed over. Run by the server, like `delegate` (load-tools). */
 export const taskSpec = {
@@ -132,13 +148,13 @@ export const taskSpec = {
     action: z.enum(["status", "answer", "cancel"]),
     task: z
       .string()
-      .nullable()
+      .nullish()
       .describe(
         "The job, by its label or by the handle a past call's transcript carries. With `status`: null for every job in one line each — that is the list — or name one to get its report in full.",
       ),
     answer: z
       .string()
-      .nullable()
+      .nullish()
       .describe(
         "With `answer`: what to tell the bot — the answer to its question, a course correction for a job still running, or what to do next on one that finished.",
       ),
@@ -157,19 +173,22 @@ export const askThursdayTool = tool({
  * the call and its result are both written to the thread, and a resumed run
  * reads a finished exchange rather than a call left hanging.
  */
-export const reportTool = tool({
-  description: reportSpec.description,
-  inputSchema: reportSpec.parameters,
-  execute: async ({ result, complete }) => {
-    const missing = await missingFiles(result);
-    if (missing.length) {
-      return `${NOT_HANDED_BACK} these files do not exist — ${missing.join(", ")}. Write them first, or take the paths out of the result.`;
-    }
-    return complete
-      ? "Handed back. The job is closed; nothing further runs."
-      : "Handed back as unfinished. The user decides whether to continue.";
-  },
-});
+export const createReportTool = (notes: boolean) => {
+  const spec = reportSpec(notes);
+  return tool({
+    description: spec.description,
+    inputSchema: spec.parameters,
+    execute: async ({ result, complete }) => {
+      const missing = await missingFiles(result);
+      if (missing.length) {
+        return `${NOT_HANDED_BACK} these files do not exist — ${missing.join(", ")}. Write them first, or take the paths out of the result.`;
+      }
+      return complete
+        ? "Handed back. The job is closed; nothing further runs."
+        : "Handed back as unfinished. The user decides whether to continue.";
+    },
+  });
+};
 
 /**
  * A report naming a workspace file that does not exist is refused: the path becomes a link