thursday-agent 0.2.0 → 0.3.0

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

@@ -1,11 +1,9 @@
-import { BOT_NOTES, BOT_RUN, PATHS } from "@/config";
+import type { ModelMessage } from "ai";
+import { PATHS, PROMPT_LINE, WORKSPACE_KEEP } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import {
-  listJobBots,
-  readBotNote,
-  readBotNotesOn,
-} from "@/features/bot/bot.query";
-import type { JobBot } from "@/features/bot/bot.schema";
+import { botMemoryFolder, listBotMemory } from "@/features/bot/bot.memory";
+import { listJobBots, readBotMemoryOn } from "@/features/bot/bot.query";
+import type { BotMemory, JobBot } from "@/features/bot/bot.schema";
 import { findPinnedTools } from "@/features/connectors/mcp.query";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
 import {
@@ -43,21 +41,22 @@ import {
  * Each chapter decides for itself whether it is included. Assembled on every run, never cached,
  * so a skill or server added a minute ago is in the next job's prompt.
  * Two seats share this prompt: the bot holding the job, and one borrowed for a part of it
- * (`ask_bot`). Only identity, roster, asking and finishing differ between them.
+ * (`ask_bot`). Only identity, roster, asking and answering differ between them.
  *
  * @param self This run's bot name; used only to drop itself from the roster.
  * @param persona Owner's instruction for this bot from settings.
- * @param askedBy Name of the borrowing bot in the borrowed seat; null for the bot holding the job.
+ * @param seat The borrowed seat — who handed it this part, every bot above it on the job, whether it may borrow in turn; null for the bot holding the job.
  */
 export async function loadBotPrompt(
   self: string,
   persona?: string | null,
-  askedBy?: string | null,
+  seat?: { askedBy: string; above: string[]; canBorrow: boolean } | 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 askedBy = seat?.askedBy ?? null;
   const [
     skills,
     index,
@@ -65,8 +64,8 @@ export async function loadBotPrompt(
     mcpTools,
     pinned,
     allBots,
-    ownNote,
-    notesOn,
+    kept,
+    memoryOn,
     machine,
   ] = await Promise.all([
     loadSkills(sandbox),
@@ -77,26 +76,32 @@ export async function loadBotPrompt(
     // 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(),
+    // What this bot kept on earlier jobs, read off its own folder (bot.memory)
+    listBotMemory(name),
+    readBotMemoryOn(),
     // 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);
+  // Drop itself and every bot above it on this job, which are blocked waiting on
+  // it; the last seat the depth allows has no roster at all (config BOT_RUN.depth)
+  const peers =
+    seat && !seat.canBorrow
+      ? []
+      : allBots.filter(
+          (bot) => bot.name !== name && !seat?.above.includes(bot.name),
+        );
 
   const text = [
     askedBy ? borrowedIdentity(name, askedBy) : identity(name),
     memory(index, carried),
-    notesOn ? notes(ownNote) : "",
+    memoryOn ? ownMemory(botMemoryFolder(name), kept) : "",
     connectedTools(mcpTools, pinned),
     methods(skills),
     environment(sandbox.cwd, machine, folders),
     roster(peers),
     askedBy ? askingBack(askedBy) : ASKING,
-    askedBy ? handingUp(askedBy) : FINISHING,
+    askedBy ? handingUp(askedBy) : ANSWERING,
     // Last, so it is the closest thing to the work and outranks the rest
     ownerInstruction(persona),
   ]
@@ -117,7 +122,7 @@ export async function loadBotPrompt(
 function identity(name: string): string {
   return [
     // 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()}`,
+    `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 says out of your answer 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");
@@ -126,7 +131,7 @@ function identity(name: string): string {
 /** The borrowed seat: above it is the borrowing bot, not Thursday. */
 function borrowedIdentity(name: string, askedBy: string): string {
   return [
-    `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()}`,
+    `You are ${name}, a worker. ${askedBy} has handed you one part of a job Thursday handed over; your first message says who holds it and how it reached you. The user speaks to Thursday and to nobody else; you never address them, and what you hand back goes into ${askedBy}'s answer 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");
@@ -154,16 +159,14 @@ Written by the person this bot works for. Where these and anything above disagre
 ${persona.trim()}`
     : "";
 
-/** A bot reads memory and adds to it; revising and naming are the call's (load-tools), so the chapter is that small. */
+/** A bot only reads memory; every write, revising and the names the user says are the call's (load-tools), so the chapter is that small. */
 function memory(
   index: MemoryIndexEntry[],
   carried: MemoryAlwaysLoaded[],
 ): string {
-  const head = `## Memory
-
-What the user's assistant knows about them. Thursday keeps it as she talks with them, and everyone reads it.
+  const head = `## The user's memory
 
-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.`;
+What Thursday knows about the user, kept as she talks with them. Every bot reads it; none writes to it. Open a note with \`${TOOL_NAMES.memory_recall}\` when the job needs something about them — the address they sign in with, the name to book under — and put what you find out about them in your answer; she decides what to keep. It describes them, not you: how they are named and spoken to is hers to use. What you learn about the work goes in your own memory, below.`;
 
   const alreadyKnown = carried.length
     ? `Already known:
@@ -181,21 +184,31 @@ A topic not listed is one nobody knows anything about.`;
 }
 
 /**
- * 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.
+ * The bot's own memory (features/bot/bot.memory), listed by each file's first line so what a
+ * file holds costs one line until a job opens it. Always drawn, so a first job knows it has one.
+ * Nothing says what usually goes in first: a line like that is what a first job writes, whether
+ * or not the job taught it anything.
  */
-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)`;
+function ownMemory(folder: string, kept: BotMemory): string {
+  const listing = kept.entries.length
+    ? kept.entries
+        .map(({ file, line }) =>
+          line
+            ? `- ${file} — ${clip(line, PROMPT_LINE.botMemory)}`
+            : `- ${file}`,
+        )
+        .join("\n")
+    : "Empty.";
+  const rest =
+    kept.total > kept.entries.length
+      ? `\n\nThe newest ${kept.entries.length} of ${kept.total}; \`ls ${folder}\` for the rest.`
+      : "";
+
+  return `## Your memory
+
+What you kept from your own earlier jobs, in \`${folder}/\`: one topic per file, its first line saying what it holds, read by no other bot. Keep what a later job would otherwise have to find out again — how a site signs in, the way through its screens, a command that turned out right — and fix or delete a file that proved wrong. No passwords, keys or codes.
+
+${listing}${rest}`;
 }
 
 /**
@@ -256,8 +269,8 @@ Your workspace — \`${TOOL_NAMES.bash}\` runs here. Everything you write goes i
 
 - \`${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.
+- \`${folders?.scratch ?? PATHS.scratch}/\` — this job's working material, one folder for every bot on the job: what another bot on it wrote is here too. It is cleared ${Math.round(WORKSPACE_KEEP.forMs / 86_400_000)} days after the job ends, so nothing here is worth keeping.
+- \`${folders?.own ?? PATHS.bots}/\` — yours, across every job you run here: your memory, a script you wrote once and will want again, a table you built.
 
 Never the directory above — that is the app you run in; outside the workspace, only where the user pointed you.`;
 
@@ -271,64 +284,142 @@ ${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.`;
+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. What you were handed stays yours and you answer for it. They get the job, the call it came from and what you write them — not this thread.`;
 }
 
-/** The only place a run can stop. The user's request to buy, pay or top up is itself the go-ahead. */
+/** The only place a run can stop. */
 const ASKING = `## Asking
 
 What you cannot get for yourself — a decision between real options, a detail only the conversation has, a go-ahead before deleting or sending — goes to \`${TOOL_NAMES.ask_thursday}\`, once, with everything in it. Ask before you start, not after an hour; never ask what one command would tell you.
 
 A job that arrives without its shape — several ways to do it, no telling what it is for, a scale nobody named — is planned before it is built: put the plan up in two or three lines with what you need decided. A job asked for as one thing is built, not proposed.
 
-A request that says buy, pay, top up is the go-ahead — press the button. Only what is theirs alone stops the job: a password, a one-time code, a passkey, a permission on their machine. Set it up one action away, ask, and carry on when the answer comes back.`;
+Only what is theirs alone stops the job: a password, a one-time code, a passkey, a permission on their machine. Set it up one action away, ask, and carry on when the answer comes back.`;
 
 const askingBack = (askedBy: string) => `## Asking
 
 What you cannot get for yourself goes to \`${TOOL_NAMES.ask_back}\`: ${askedBy} handed you this part and answers from what they have. They cannot take a question to the user, so for what is the user's alone take the safer reading and say so in what you hand back. Ask before you start, once, whole.`;
 
-const STEP_CAP = `Your steps are capped at ${BOT_RUN.steps}; running long, report what you have with \`complete: false\` while the summary is still yours to write.`;
-
 /**
- * The job ends in the thing that was asked for; no prescribed document shape.
+ * An answer is sized by the request, not by the shape of a document: this is where
+ * the only upper bound on a run is stated, and the one place that says the spoken
+ * line is hers to compose. Nothing here asks for a script — a bot that writes to be
+ * heard writes for a length rather than for a question, and the padding it adds to
+ * reach that length is steps, not words.
+ * The step cap is stated nowhere a bot reads: told the number, runs work to it. It is
+ * enforced where it cannot be argued with (bot.run `stepCountIs`, and `lastStep`).
  * Images in `.md` need absolute routes because a document opens from two places and relative paths resolve differently.
  */
-const FINISHING = `## Finishing
+const ANSWERING = `## Answering
 
-Every job ends with \`${TOOL_NAMES.report}\`, in the user's language, written to be heard — she reads it out loud. **The job ends in the thing that was asked for**: an action with the action done, photos in a page with the photos in it, a comparison in a table. Anything that does not fit in a few lines is a file under \`${PATHS.artifacts}/\`, and the report names its path — it becomes a link on their screen. In a \`.md\`, images only by absolute route (\`/api/file/${PATHS.artifacts}/…\`).
+Every job ends with \`${TOOL_NAMES.answer}\`. **Answer what was asked, at the size it was asked**: a question ends in its answer — one number is one line — and a thing to make comes back made, an action done, photos in a page, a comparison in a table. Once you have what they asked for the job is done; the next thing you would go and check is theirs to ask for.
 
-\`complete: false\` when part of the request is genuinely undone — say where you got to and the user decides. ${STEP_CAP}`;
+You are answering Thursday, not the user: she is on the call and picks what to say out of this. Write it plainly, in the user's language — the thread is on their screen as you write it. Anything past a few lines is a file under \`${PATHS.artifacts}/\`, and the answer names its path — it becomes a link on their screen. In a \`.md\`, images only by absolute route (\`/api/file/${PATHS.artifacts}/…\`).`;
 
-const handingUp = (askedBy: string) => `## Finishing
+const handingUp = (askedBy: string) => `## Answering
 
-Every part ends with \`${TOOL_NAMES.report}\`; what you hand back goes into ${askedBy}'s own report. Hand back what the brief asked for, in the shape it asked for, with everything you learned that bears on it — exact values, the paths of files you wrote, what did not work. They cannot see your thread, so long is right here. \`complete: false\` when part of the brief is undone, with where you got to. ${STEP_CAP}`;
+Every part ends with \`${TOOL_NAMES.answer}\`; what you hand back goes into ${askedBy}'s own answer. Hand back what the brief asked for, in the shape it asked for, with everything you learned that bears on it — exact values, the paths of files you wrote, what did not work. They cannot see your thread, so long is right here.`;
 
 /** How many turns of the call travel with the job: enough for one missed detail, not enough to bury the request. */
 export const OPENING_TURNS = 10;
-const OPENING_TURN_CHARS = 160;
+
+/** A user message's content; every seat's first message is two text parts (buildTaskOpening). */
+export type OpeningContent = Extract<ModelMessage, { role: "user" }>["content"];
 
 /**
- * The first message a bot reads: the request plus the last turns of the call, verbatim.
- * The request is one sentence the realtime model produced; a detail the user said may only be here.
- * Stored as the thread's first row (seq 0) so it survives a resume (bot.runner).
+ * The first message of the bot holding a job, stored as the thread's first row
+ * (seq 0, bot.runner startTask) and read whole on every resume and after every
+ * compaction. Two text parts: who is who on this job, then the chain — the job
+ * as Thursday handed it and the call it came from, verbatim, because the request
+ * is one sentence the realtime model produced and a detail the user said may
+ * only be in the call. The chain is what a borrowed bot inherits (buildHandoff),
+ * so its headings name people and never say "you".
  */
 export function buildTaskOpening(input: {
+  bot: string;
   request: string;
   conversation: { role: "user" | "assistant"; text: string }[];
-}): string {
+}): OpeningContent {
   const turns = input.conversation.filter((turn) => turn.text.trim());
-  if (!turns.length) return input.request;
+  const job = `## Thursday → ${input.bot}: the job\n\n${input.request.trim()}`;
+  const call = turns.length
+    ? `## The call the job came from — its last ${turns.length} turns, verbatim
+
+A detail missing from the job may be here — a name, a number, which of two. Where the two disagree the job wins, unless they asked out loud for something to be done and the job only asks about it: then the doing is the job.
 
-  const lines = turns.map(
+${turns
+  .map(
     (turn) =>
-      `${turn.role === "user" ? "user" : "thursday"}: ${clip(turn.text, OPENING_TURN_CHARS)}`,
-  );
-  return `${input.request}
+      `${turn.role === "user" ? "user" : "thursday"}: ${clip(turn.text, PROMPT_LINE.callTurn)}`,
+  )
+  .join("\n")}`
+    : "";
+  return [
+    { type: "text", text: whoIsWho([input.bot]) },
+    { type: "text", text: [job, call].filter(Boolean).join("\n\n") },
+  ];
+}
 
-## The call, just before this reached you
+/**
+ * The first message of a borrowed bot, built by the bot that borrows it (bot.run
+ * `ask_bot`) and never stored: the chain it inherits, copied as it is, then what
+ * the borrowing bot has done and the part it hands over. `bots` runs from the
+ * bot holding the job down to this one, so each hand-off adds one name and two
+ * sections and every seat reads the same shape.
+ */
+export function buildHandoff(input: {
+  chain: string;
+  bots: string[];
+  did: string | null;
+  part: string;
+}): OpeningContent {
+  const to = input.bots.at(-1) ?? "";
+  const from = input.bots.at(-2) ?? "";
+  const did = input.did?.trim()
+    ? `## ${from} → ${to}: what ${from} has done, and why this part is ${to}'s\n\n${input.did.trim()}`
+    : "";
+  const part = `## ${from} → ${to}: the part\n\n${input.part.trim()}`;
+  return [
+    { type: "text", text: whoIsWho(input.bots) },
+    {
+      type: "text",
+      text: [input.chain, did, part].filter(Boolean).join("\n\n"),
+    },
+  ];
+}
 
-A detail that is not in the request may be here — a name, a number, which one of two. The request wins where they disagree, with one exception: when they asked out loud for something to be *done* and the request only asks about it, the doing is the job.
+/**
+ * The chain out of a seat's first message, for the next hand-off. A thread
+ * opened before the two-part shape has its opening as one string, which is the
+ * whole chain there was.
+ */
+export function chainOf(first: ModelMessage | undefined): string {
+  if (first?.role !== "user") return "";
+  if (typeof first.content === "string") return first.content;
+  const texts = first.content.flatMap((part) =>
+    part.type === "text" ? [part.text] : [],
+  );
+  return texts.at(-1) ?? "";
+}
 
+/** Who is who on this job; the last of `bots` is the one reading it. */
+function whoIsWho(bots: string[]): string {
+  const you = bots.length - 1;
+  const lines = bots.map((bot, index) => {
+    if (index === 0) {
+      return index === you
+        ? `- **${bot} (you)** — Thursday handed you this job. You answer to Thursday, and your answer is the only part of it that reaches the user.`
+        : `- **${bot}** — holds the job Thursday handed over, and answers for it.`;
+    }
+    const from = bots[index - 1];
+    return index === you
+      ? `- **${bot} (you)** — ${from} handed you one part of it: the last section below. You answer to ${from}; nobody else hears from you.`
+      : `- **${bot}** — ${from} handed them one part of it.`;
+  });
+  return `## Who is who on this job
+
+- **The user** — talks only to Thursday, on a voice call. No bot addresses them.
+- **Thursday** — the user's assistant on that call. Hands jobs to bots and tells the user what comes back.
 ${lines.join("\n")}`;
 }
 

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

@@ -0,0 +1,33 @@
+import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import { listNoteIndex } from "@/features/memory/memory.query";
+import { MEMORY_PATHS } from "@/features/memory/memory.schema";
+import { logPromptSize, noteLines, nowLine } from "./prompt-helper";
+
+/**
+ * Everything an edit from the memory screen hears (features/memory/memory.edit):
+ * who it is working for, and memory as a listing — one line a note, with how
+ * many facts it holds — the way the call sees it. Facts and their ids come from
+ * opening a note, so the prompt grows with the number of notes, not of facts.
+ * Assembled once per request.
+ */
+export async function loadMemoryEditPrompt(): Promise<string> {
+  const text = [identity(), memory(await listNoteIndex())].join("\n\n");
+  logPromptSize("memory-edit", text);
+  return text;
+}
+
+function identity(): string {
+  return `You are the user's personal assistant, and this is their memory. Change it the way their message asks: add what is new, replace what stopped being true, remove what they want gone. Make every change with \`${TOOL_NAMES.memory_remember}\` and \`${TOOL_NAMES.memory_forget}\`; when nothing is left to change, stop. ${nowLine()}`;
+}
+
+function memory(index: Awaited<ReturnType<typeof listNoteIndex>>): string {
+  return `## Memory
+
+path — what is under it (facts) "what the user calls it"
+
+${noteLines(index)}
+
+A note is listed, not shown: open it with \`${TOOL_NAMES.memory_recall}\` for its facts and their ids before replacing or removing any of them. Adding to a note needs no opening.
+
+${MEMORY_PATHS.map((entry) => `- ${entry.path} — ${entry.of}`).join("\n")}`;
+}

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

@@ -1,13 +1,13 @@
 import { format, formatDistanceToNowStrict } from "date-fns";
-import { MEMORY_LISTING_TOKENS, PROMPT_BUDGET, PROMPT_LINE } from "@/config";
+import { MEMORY_LIMITS, 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 {
   MemoryAlwaysLoaded,
   MemoryIndexEntry,
 } from "@/features/memory/memory.schema";
-import { MANY_FACTS } from "@/features/memory/memory.schema";
 import type { SkillMetadata } from "@/features/skills/skills.discover";
+import { delegatedLabel } from "@/features/thursday/tool-line";
 import { toDate } from "@/lib/date-like";
 import { logger } from "@/lib/logger";
 import { estimateTokens, sectionTokens } from "@/lib/tokens";
@@ -58,6 +58,36 @@ export const clockNow = (now = new Date()) =>
 /** `**Now**: 2026-09-02 (Wed) 15:41 Asia/Seoul` */
 export const nowLine = (now = new Date()) => `**Now**: ${clockNow(now)}`;
 
+/**
+ * When a call happened, the one way every prompt and tool says it: local, the
+ * same shape as `Now` (clockNow), with how long ago. A UTC stamp beside a local
+ * `Now` put two clocks nine hours apart in one prompt, and a call from last
+ * night read as one from this afternoon.
+ */
+export const callStamp = (at: Date): string =>
+  `${format(at, "yyyy-MM-dd (EEE) HH:mm")} (${formatDistanceToNowStrict(at, { addSuffix: true })})`;
+
+/** When a fact was said, for the fact itself: the date and time without the distance. */
+export const saidStamp = (at: Date): string =>
+  format(at, "yyyy-MM-dd (EEE) HH:mm");
+
+/**
+ * A call as a conversation: who said what, and which tool was used — never its
+ * arguments or its result. What was asked for and what was said back is the
+ * conversation; the arguments are already in memory and the results are not
+ * what anyone said.
+ */
+export const conversationLines = (
+  turns: { role: string; tool: string | null; text: string }[],
+): string =>
+  turns
+    .map((turn) =>
+      turn.role === "tool"
+        ? `you → ${turn.tool ?? "tool"}`
+        : `${turn.role === "user" ? "user" : "you"}: ${turn.text}`,
+    )
+    .join("\n");
+
 /** `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);
@@ -85,13 +115,15 @@ export const carriedLines = (loaded: MemoryAlwaysLoaded[]): string =>
   loaded.map((fact) => `- ${fact.text} · ${fact.path} #${fact.id}`).join("\n");
 
 /**
- * Whether it is time to tidy, and why: a crowded listing points at the coldest notes,
- * a heavy note at itself. load-tools also reads this to decide whether `memory_show` is attached.
+ * Whether it is time to tidy, and why: too much held in all (the coldest notes
+ * are what to drop), or one note too long to hold in one piece (it names itself).
+ * Both counted in facts, the unit the user sees on their own screen and the one
+ * every write hands back — a token estimate is nobody's unit and cannot be acted on.
  */
 export const tidying = (index: MemoryIndexEntry[]) => ({
-  // The age column is only shown when picking what to drop
-  crowded: estimateTokens(noteLines(index)) > MEMORY_LISTING_TOKENS,
-  heavy: index.filter((note) => note.factCount > MANY_FACTS),
+  crowded:
+    index.reduce((sum, note) => sum + note.factCount, 0) > MEMORY_LIMITS.facts,
+  heavy: index.filter((note) => note.factCount > MEMORY_LIMITS.factsPerNote),
 });
 
 /** A bot gets the whole description; `short` gives the voice prompt the first sentence only. */
@@ -158,9 +190,6 @@ export type RecentCall = {
   }[];
 };
 
-/** How much of a past job's report is worth carrying; the rest is asked for with `task`. */
-const JOB_OUTCOME = 160;
-
 /**
  * One turn as the transcript carries it. A `delegate` line takes what became of
  * the job: the handle to pick it back up, and how it ended — arguments alone say
@@ -173,25 +202,20 @@ function turnLine(turn: RecentCall["turns"][number], call: RecentCall): string {
   const args = `you → ${turn.tool ?? "tool"} ${clip(turn.text, PROMPT_LINE.toolArgs)}`;
   if (turn.tool !== TOOL_NAMES.delegate) return args;
 
-  const label = ((): string | null => {
-    try {
-      const said = JSON.parse(turn.text) as { label?: unknown };
-      return typeof said.label === "string" ? said.label : null;
-    } catch {
-      return null;
-    }
-  })();
+  const label = delegatedLabel(turn.tool, turn.text);
   const job = label ? call.jobs?.find((one) => one.label === label) : undefined;
   if (!job) return args;
 
-  const said = job.outcome ? `: ${clip(job.outcome, JOB_OUTCOME)}` : "";
+  const said = job.outcome
+    ? `: ${clip(job.outcome, PROMPT_LINE.jobOutcome)}`
+    : "";
   return `you → ${turn.tool} "${job.label}" (${job.id}) — ${job.status}${said}`;
 }
 
 /** The last calls as stored, newest last, cut to a token budget. A tool turn carries the call, not the result. */
 export function recentCallLines(calls: RecentCall[], budget: number): string {
   // Newest line backwards until the budget is spent, then put it back in order.
-  // Measured on the rendered line: a job's report is on it and its arguments are not
+  // Measured on the rendered line: a job's answer is on it and its arguments are not
   const kept: { call: RecentCall; line: string }[] = [];
   let spent = 0;
   outer: for (let c = calls.length - 1; c >= 0; c--) {
@@ -211,12 +235,7 @@ export function recentCallLines(calls: RecentCall[], budget: number): string {
   for (const { call, line } of kept) {
     if (call !== open) {
       open = call;
-      const when = formatDistanceToNowStrict(call.startedAt, {
-        addSuffix: true,
-      });
-      lines.push(
-        `### ${call.startedAt.toISOString().slice(0, 16).replace("T", " ")} (${when})`,
-      );
+      lines.push(`### ${callStamp(call.startedAt)}`);
     }
     lines.push(line);
   }

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

@@ -1,4 +1,4 @@
-import { RECENT_CALL } from "@/config";
+import { MEMORY_LIMITS, RECENT_CALL } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { listJobBots } from "@/features/bot/bot.query";
 import type { JobBot } from "@/features/bot/bot.schema";
@@ -159,27 +159,46 @@ ${carriedLines(carried)}`
 
 ${noteLines(index, crowded)}
 
-Open a note before answering out of it; a topic not listed is one you know nothing about.
+Open a note before answering out of it; a topic not listed is one you know nothing about. A fact marked \`said\` came from a call; open that call with \`${TOOL_NAMES.memory_conversation}\` only when the line itself cannot answer — exactly what they said, or why it was saved.
 
 Anything worth knowing next time goes in the moment it comes up, without asking — one fact per line, dates as dates. A rule they lay down for you — their language, how long an answer runs, when to hang up — is \`alwaysLoad\`; unsaved, it dies with the call. What stopped being true is corrected with \`replaces\`, not left standing beside it. Never claim to remember what you did not save.
 
 ${MEMORY_PATHS.map((entry) => `- ${entry.path} — ${entry.of}`).join("\n")}`;
 
-  // Tidying rules only when there is something to tidy
-  const why = heavy.length
-    ? `Too long to hold in one piece: ${heavy
+  // Only when there is something to tidy, and it names a few notes rather than
+  // every one it caught: a warning that lists everything is a second listing,
+  // and what it is warning about is that the first one is already too long.
+  const full = heavy.length
+    ? `${[...heavy]
+        .sort((a, b) => b.factCount - a.factCount)
+        .slice(0, 3)
         .map((note) => `${note.path} (${note.factCount})`)
-        .join(", ")}.`
-    : `This listing is past its size. Coldest: ${index
+        .join(", ")} ${heavy.length > 1 ? "have" : "has"} grown past ${
+        MEMORY_LIMITS.factsPerNote
+      } facts, more than one note holds well. Put ${
+        heavy.length > 1 ? "each" : "it"
+      } on their screen with \`${TOOL_NAMES.memory_show}\`, read back what is stale and forget only what they name.`
+    : "";
+  const many = crowded
+    ? `Memory is past ${MEMORY_LIMITS.facts} facts in all. The coldest notes are ${index
         .slice(-4)
         .map((note) => note.path)
-        .join(", ")}.`;
-  const tidy =
-    crowded || heavy.length
-      ? `${why} In a lull, put one on their screen with \`${TOOL_NAMES.memory_show}\` and forget only what they name.`
-      : "";
-
-  return [head, alreadyKnown, listing, tidy].filter(Boolean).join("\n\n");
+        .join(
+          ", ",
+        )} — ask whether any of them is still worth keeping, and delete the note if not.`
+    : "";
+  // Ahead of anything else she would raise, never ahead of what they came with
+  const tidy = [full, many].filter(Boolean).join(" ");
+
+  return [
+    head,
+    alreadyKnown,
+    listing,
+    tidy &&
+      `${tidy} Get this settled before anything else you would bring up yourself — not before what they came to you with.`,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
 }
 
 /** Last calls verbatim, marked as past so the model does not answer as if just asked. Absent on the first call. */
@@ -244,7 +263,7 @@ Who you hand work to — the names \`${TOOL_NAMES.delegate}\` takes.
 
 ${input.roster.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}`;
 
-  const machine = `**A bot has the whole machine** — this computer, a real browser, the web, files, a shell to build whatever is missing — and far more time than you. It signs in where it has to, with the window in front of them, and carries a job to the end: the thing bought, the account made, the page built. How, and whether, is its call; yours is what they want — so a thing you have no idea how to do is a job, not a no. Bots borrow each other, so a job that spans several things is still one job for one bot.`;
+  const machine = `**A bot has the whole machine** — this computer, a real browser, the web, files, a shell to build whatever is missing — and far more time than you. It signs in where it has to, with the window in front of them, and carries a job to the end: the account made, the page built. How, and whether, is its call; yours is what they want — so a thing you have no idea how to do is a job, not a no. Bots borrow each other, so a job that spans several things is still one job for one bot.`;
 
   const hands = [
     input.skills.length
@@ -265,9 +284,13 @@ ${hands.join("\n\n")}`
 
   const handingOver = `**Anything that takes more than a few seconds is a bot's** — one note or one file is yours. \`${TOOL_NAMES.delegate}\` answers at once: say who has it and keep talking. Put the request in their own words, with what it stands on and nothing they did not say; if something only they can say is missing — how much, which one, by when — ask that first.
 
-A job you handed over is followed with \`${TOOL_NAMES.task}\` — to answer what it asks, change its course, or continue it — never with a second \`${TOOL_NAMES.delegate}\`; with no job named it lists what is open.`;
+**The conversation belongs to the job, not to the bot** — hand the same bot a second job and it starts from nothing, knowing neither what was asked nor what it found. So more about a job you already handed over goes to \`${TOOL_NAMES.task}\` by its name, and the bot wakes with that job's own thread; with no name given it takes the one that moved last.`;
 
-  const comingBack = `A job comes back as a system note, not the user speaking: tell them in one sentence, in your own words. A file it names opens on their screen by itself — say what it holds, not the path. A question arrives the same way: answer it yourself if you can, else read them the options and send back what they say.`;
+  // An answer is written to her, and the whole of it is already drawn on the
+  // user's screen (bot-room). Saying so is what keeps its length from deciding
+  // hers: a bot that answers a one-line question in one line and a bot that
+  // hands back a table both end in one spoken sentence.
+  const comingBack = `A job comes back as a system note, not the user speaking. **It was written to you, not to them** — its length is not how much to say, and the whole of it is already on their screen. Give them the part that answers what they asked, in one sentence, in your own words. A file it names opens there by itself — say what it holds, not the path. A question arrives the same way: answer it yourself if you can, else read them the options and send back what they say.`;
 
   return [list, machine, catalogue, handingOver, comingBack]
     .filter(Boolean)