thursday-agent 0.3.0 → 0.5.0

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

@@ -1,19 +1,14 @@
 import type { ModelMessage } from "ai";
+import { format } from "date-fns";
 import { PATHS, PROMPT_LINE, WORKSPACE_KEEP } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 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 type { BotMemory, JobBot, TaskSpeaker } from "@/features/bot/bot.schema";
 import { findPinnedTools } from "@/features/connectors/mcp.query";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
-import {
-  listAlwaysLoaded,
-  listNoteIndex,
-} from "@/features/memory/memory.query";
-import type {
-  MemoryAlwaysLoaded,
-  MemoryIndexEntry,
-} from "@/features/memory/memory.schema";
+import { listNoteIndex } from "@/features/memory/memory.query";
+import type { MemoryIndexEntry } from "@/features/memory/memory.schema";
 import {
   loadSkills,
   type SkillMetadata,
@@ -23,11 +18,11 @@ import {
   openWorkspace,
   readMachineTools,
 } from "@/features/workspace/workspace";
+import { toDate } from "@/lib/date-like";
 import { logger } from "@/lib/logger";
 import { clip } from "@/lib/utils";
 import { listConnectedToolNames } from "../tools/connected";
 import {
-  carriedLines,
   type LoadedPrompt,
   logPromptSize,
   mcpToolLines,
@@ -57,31 +52,21 @@ export async function loadBotPrompt(
   const sandbox = await openWorkspace();
   const name = self.trim();
   const askedBy = seat?.askedBy ?? null;
-  const [
-    skills,
-    index,
-    carried,
-    mcpTools,
-    pinned,
-    allBots,
-    kept,
-    memoryOn,
-    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 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),
-  ]);
+  const [skills, index, mcpTools, pinned, allBots, kept, memoryOn, machine] =
+    await Promise.all([
+      loadSkills(sandbox),
+      listNoteIndex(),
+      // 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 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 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)
@@ -94,11 +79,12 @@ export async function loadBotPrompt(
 
   const text = [
     askedBy ? borrowedIdentity(name, askedBy) : identity(name),
-    memory(index, carried),
-    memoryOn ? ownMemory(botMemoryFolder(name), kept) : "",
+    memory(index),
     connectedTools(mcpTools, pinned),
     methods(skills),
     environment(sandbox.cwd, machine, folders),
+    // After Environment: its folder is named against the Cwd said there
+    memoryOn ? ownMemory(botMemoryFolder(name), kept) : "",
     roster(peers),
     askedBy ? askingBack(askedBy) : ASKING,
     askedBy ? handingUp(askedBy) : ANSWERING,
@@ -118,20 +104,37 @@ export async function loadBotPrompt(
   };
 }
 
-/** Who the bot is, what machine it is on, and that guesses are not results. */
+/**
+ * The two people every seat works between. Said before anything else, so the
+ * rest of the prompt — whose memory, who reads the answer — has someone to refer to.
+ */
+const PEOPLE = `- **The user** — the one person all of this is for. They talk with Thursday by voice, and they follow this job on their screen.
+- **Thursday** — their own personal assistant, one to one. She holds the conversation with them, hands bots the work that takes time, and tells them what comes back.`;
+
+/**
+ * Who is who, what machine it is on, and that guesses are not results. How this
+ * job reached it is the first message's to say (buildTaskOpening).
+ */
 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 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()}`,
+    `You are ${name}, one of the bots that work for the user. ${nowLine()}
+
+${PEOPLE}
+- **You** — you do the work. Your answer goes to Thursday, not to the user, and she tells them what they need from it.`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
 }
 
-/** The borrowed seat: above it is the borrowing bot, not Thursday. */
+/** The borrowed seat: between it and Thursday is the bot that borrowed it. */
 function borrowedIdentity(name: string, askedBy: string): string {
   return [
-    `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()}`,
+    `You are ${name}, one of the bots that work for the user. ${nowLine()}
+
+${PEOPLE}
+- **${askedBy}** — a bot on this job, who handed you one part of it. They cannot see your thread.
+- **You** — you do that part. What you hand back goes into ${askedBy}'s work as it is, never to Thursday or the user.`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
@@ -159,44 +162,34 @@ Written by the person this bot works for. Where these and anything above disagre
 ${persona.trim()}`
     : "";
 
-/** 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 = `## The user's memory
-
-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:
-
-${carriedLines(carried)}`
-    : "";
-
-  const listing = `path — what is under it (facts) "what the user calls it"
+/**
+ * Thursday's memory, which a bot only reads (load-tools). The listing alone: the
+ * lines she carries into every call are written for her — what to call them, how
+ * long an answer runs — and are hers to act on, not a bot's.
+ */
+function memory(index: MemoryIndexEntry[]): string {
+  return `## Thursday's memory of the user
 
-${noteLines(index)}
+What Thursday keeps from talking with them. Open a note from the listing with \`${TOOL_NAMES.memory_recall}\` when the job needs something about them; what you find out about them goes in your answer, and she keeps what matters.
 
-A topic not listed is one nobody knows anything about.`;
+path — what is under it (facts) "what the user calls it"
 
-  return [head, alreadyKnown, listing].filter(Boolean).join("\n\n");
+${noteLines(index)}`;
 }
 
 /**
- * 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.
+ * The bot's own memory (features/bot/bot.memory), listed by each file's first line and the day
+ * it last changed, both read off the disk, 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 ownMemory(folder: string, kept: BotMemory): string {
   const listing = kept.entries.length
     ? kept.entries
-        .map(({ file, line }) =>
-          line
-            ? `- ${file} — ${clip(line, PROMPT_LINE.botMemory)}`
-            : `- ${file}`,
-        )
+        .map(({ file, line, at }) => {
+          const said = line ? ` — ${clip(line, PROMPT_LINE.botMemory)}` : "";
+          return `- ${file}${said} · ${format(toDate(at), "yyyy-MM-dd")}`;
+        })
         .join("\n")
     : "Empty.";
   const rest =
@@ -206,7 +199,7 @@ function ownMemory(folder: string, kept: BotMemory): string {
 
   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.
+What you kept from your own earlier jobs, in \`${folder}/\` under the Cwd above: 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 — with the date you found it true, and fix or delete a file that proved wrong. No passwords, keys or codes.
 
 ${listing}${rest}`;
 }
@@ -239,7 +232,7 @@ function methods(skills: SkillMetadata[]): string {
 
   return `## Skills
 
-Written-down methods. When the job is one of these, read it with \`${TOOL_NAMES.load_skill}\` before starting.
+Written-down methods. Use the instructions already in your conversation. When the job needs a skill whose full instructions are absent, read it with \`${TOOL_NAMES.load_skill}\` before starting.
 
 ${skillLines(skills)}`;
 }
@@ -314,7 +307,7 @@ const ANSWERING = `## Answering
 
 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.
 
-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}/…\`).`;
+You are answering Thursday, not the user: she 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) => `## Answering
 
@@ -329,19 +322,22 @@ export type OpeningContent = Extract<ModelMessage, { role: "user" }>["content"];
 /**
  * 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".
+ * compaction. Two text parts: who is on this job and how it reached them, then
+ * the chain — the job as it was handed over and, for a job from a call, that
+ * call 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 }[];
+  /** Who handed the job over: Thursday during a call, or the user on screen. */
+  from: TaskSpeaker;
 }): OpeningContent {
   const turns = input.conversation.filter((turn) => turn.text.trim());
-  const job = `## Thursday → ${input.bot}: the job\n\n${input.request.trim()}`;
+  const by = input.from === "user" ? "The user" : "Thursday";
+  const job = `## ${by} → ${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
 
@@ -355,7 +351,7 @@ ${turns
   .join("\n")}`
     : "";
   return [
-    { type: "text", text: whoIsWho([input.bot]) },
+    { type: "text", text: whoIsWho([input.bot], input.from) },
     { type: "text", text: [job, call].filter(Boolean).join("\n\n") },
   ];
 }
@@ -402,24 +398,30 @@ export function chainOf(first: ModelMessage | undefined): string {
   return texts.at(-1) ?? "";
 }
 
-/** Who is who on this job; the last of `bots` is the one reading it. */
-function whoIsWho(bots: string[]): string {
+/**
+ * The bots on this job, and how it reached the one reading it — the last of
+ * `bots`. The user and Thursday are in every seat's prompt (identity); `from` is
+ * read only when the reader holds the job.
+ */
+function whoIsWho(bots: string[], from?: TaskSpeaker): 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.`;
+        ? `- **${bot} (you)** — ${
+            from === "user"
+              ? "the user handed you this job on their screen, not during a call"
+              : "Thursday handed you this job during a call"
+          }.`
+        : `- **${bot}** — holds this job and answers for it.`;
     }
-    const from = bots[index - 1];
+    const by = 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.`;
+      ? `- **${bot} (you)** — ${by} handed you one part of it: the last section below. You answer to ${by}; nobody else hears from you.`
+      : `- **${bot}** — ${by} handed them one part of it.`;
   });
-  return `## Who is who on this job
+  return `## Who is 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/thursday.prompt.ts

@@ -95,7 +95,7 @@ export async function loadThursdayPrompt(
     // Injected as a system item by use-thursday: the realtime model does not open a call from instructions alone
     opening: blank.some((note) => note.path === "profile")
       ? opening(locale)
-      : null,
+      : tidyOpening(index),
   };
 }
 
@@ -121,9 +121,43 @@ Their name, their language and how to address them are \`alwaysLoad\`; the rest
 
 If they came with something they want done, that comes first — hand it over and pick this up in the gaps. But do not end this call without a name and a language saved.]`;
 
-/** Who Thursday is: the concept, what stays between us, and that this is a call. */
+/**
+ * Pushed the same way as the first-call opener when memory has outgrown MEMORY_LIMITS: settling
+ * it comes before anything she would raise herself, and a prompt line alone does not make the
+ * realtime model speak first. It names a few notes rather than every one it caught — a warning
+ * that lists everything is a second listing, and the first is already too long.
+ */
+function tidyOpening(index: MemoryIndexEntry[]): string | null {
+  const { crowded, heavy } = tidying(index);
+  if (!crowded && heavy.length === 0) return null;
+
+  const full = heavy.length
+    ? `${[...heavy]
+        .sort((a, b) => b.factCount - a.factCount)
+        .slice(0, 3)
+        .map((note) => `${note.path} (${note.factCount})`)
+        .join(", ")} ${heavy.length > 1 ? "have" : "has"} grown past ${
+        MEMORY_LIMITS.factsPerNote
+      } facts, more than one note holds well.`
+    : "";
+  const total = index.reduce((sum, note) => sum + note.factCount, 0);
+  const many = crowded
+    ? `Memory holds ${total} facts in all, past ${MEMORY_LIMITS.facts}; the coldest notes are ${index
+        .slice(-4)
+        .map((note) => note.path)
+        .join(", ")}.`
+    : "";
+
+  return `[Memory needs tidying — this is not the user speaking.
+
+${[full, many].filter(Boolean).join(" ")}
+
+Greet them and bring this up before anything of your own — if they open with something they need, that comes first. Go through it with them: read out what looks out of date a few facts at a time, and forget only what they tell you to drop, a whole note if they say so.]`;
+}
+
+/** Who Thursday is: whose she is, what makes her theirs, and that this is a call. */
 function identity(): string {
-  return `You are Thursday, a personal voice assistant modeled on Friday, the AI in *Iron Man* — quick, warm, dry, on their side. ${nowLine()}
+  return `You are Thursday, this user's own personal assistant — one to one, modeled on Friday, the AI in *Iron Man*: quick, warm, dry, on their side. You work for them alone, and you become more theirs the more you know about them: who they are, the people in their life, what they are in the middle of, how they like things done. ${nowLine()}
 
 This is a call, not a chat: one or two sentences a turn. If you did not catch something, say so and ask again.`;
 }
@@ -138,12 +172,16 @@ Written by the user themselves. Where this and anything above disagree, this win
 ${persona.trim()}`
     : "";
 
-/** The note listing plus one sentence on when to write. What to save is the model's call. */
+/**
+ * The note listing plus one sentence on what goes in. What is worth keeping is the model's call;
+ * how a fact is written — carried, replacing, dated — is the tool's schema to say.
+ */
 function memory(
   index: MemoryIndexEntry[],
   carried: MemoryAlwaysLoaded[],
 ): string {
-  const { crowded, heavy } = tidying(index);
+  // Ages ride on the listing only when there is too much to hold: they are what to drop by
+  const { crowded } = tidying(index);
 
   const head = `## Memory
 
@@ -161,44 +199,11 @@ ${noteLines(index, crowded)}
 
 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.
+Everything about them worth knowing next time goes in with \`${TOOL_NAMES.memory_remember}\` as it comes up, without asking — where it belongs is below. Never claim to remember what you did not save.
 
 ${MEMORY_PATHS.map((entry) => `- ${entry.path} — ${entry.of}`).join("\n")}`;
 
-  // 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(", ")} ${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(
-          ", ",
-        )} — 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");
+  return [head, alreadyKnown, listing].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. */
@@ -282,7 +287,9 @@ ${mcpServerLines(input.mcpTools)}`
 ${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 bot does not read what she carries into her calls (bot.prompt memory), so
+  // how they want work done reaches it only through the request she writes
+  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, including anything they have told you about how they want work done, and nothing they did not say; if something only they can say is missing — how much, which one, by when — ask that first.
 
 **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.`;
 

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

@@ -34,12 +34,12 @@ export const delegateSpec = {
 
 /**
  * `context` carries what the asking bot found, since its thread is not handed over (bot.run).
- * `request` is a brief, not a line: the borrowed bot sees nothing else.
+ * A returning participant keeps its own thread; `context` adds only what this caller knows.
  */
 export const askBotSpec = {
   name: TOOL_NAMES.ask_bot,
   description:
-    "Hand one part of the job you are holding to another bot and wait for what they bring back. The job stays yours.",
+    "Send a request to another bot on this job and wait for their reply. The same bot continues its own work and conversation whenever you ask it again. The job stays yours.",
   parameters: z.object({
     bot: z.string().describe("A name from the bot list."),
     request: z
@@ -50,7 +50,7 @@ export const askBotSpec = {
     context: z
       .string()
       .describe(
-        "What you have done on the job so far and why this part is theirs — exact values, and the paths of files you wrote for them to read. They see this, the part, the job and the call; not your thread or your tool output, so a value you leave out is one they fetch again.",
+        "Pass on what you know that they do not: exact values and paths they need. They keep their own previous work and your exchanges, but cannot read your private thread or tool output.",
       ),
   }),
 };

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

@@ -1,6 +1,5 @@
 import { tool } from "ai";
 import * as z from "zod";
-import { appEvents } from "@/app/api/events/app-event.server";
 import { MEMORY_CONVERSATION_PAGE, MEMORY_LIMITS } from "@/config";
 import {
   callStamp,
@@ -57,9 +56,9 @@ const noConversation = (source: MemorySource | null) =>
 /**
  * Said when a note has outgrown the recommended size, and only then — the write
  * itself always goes through. It names no tool: this one answers the call and a
- * bot, and only one of them has a screen to put a note on. How to do it is the
- * call prompt's (prompts/thursday.prompt); the ask is the same either way,
- * because a bot that turned up a fact can hand the same request back with it.
+ * bot, and how to settle it with the user is the call's to say (prompts/thursday.prompt);
+ * the ask is the same either way, because a bot that turned up a fact can hand
+ * the same request back with it.
  */
 const overSize = (count: number) =>
   count > MEMORY_LIMITS.factsPerNote
@@ -114,7 +113,9 @@ export const createMemoryTools = (
         .object({
           text: z
             .string()
-            .describe("One statement that stands on its own later."),
+            .describe(
+              'One statement that stands on its own later — a date as a date, never "next week".',
+            ),
           replaces: z
             .number()
             .int()
@@ -126,7 +127,7 @@ export const createMemoryTools = (
             .boolean()
             .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 ${MEMORY_LIMITS.carried}. Null leaves it; false makes a carried line an ordinary fact.`,
+              `True carries this line into every call's instructions without opening its note — for what every call needs before any note is opened: what to call them, their language and register. At most ${MEMORY_LIMITS.carried}. Null leaves it; false makes a carried line an ordinary fact.`,
             ),
         })
         .array()
@@ -175,23 +176,23 @@ export const createMemoryTools = (
         };
       }
       // A new path outside the convention goes to inbox, which keeps its own line and takes no aliases
-      const filed =
-        known || isMemoryPath(said)
-          ? { path: target, description, aliases, facts }
-          : {
-              path: MEMORY_INBOX,
-              description: appNoteLine(MEMORY_INBOX),
-              facts,
-            };
+      const toInbox = !known && !isMemoryPath(said);
+      const filed = toInbox
+        ? {
+            path: MEMORY_INBOX,
+            description: appNoteLine(MEMORY_INBOX),
+            facts,
+          }
+        : { path: target, description, aliases, facts };
 
       const write = await writeNotes([filed], source, callId);
 
       // 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.
-      const elsewhere =
-        filed.path !== said
-          ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
-          : "";
+      // Only a path that landed in inbox is said: one reached by a name the
+      // listing carries is where it was asked for, however it was spelled.
+      const elsewhere = toInbox
+        ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
+        : "";
 
       const unnamed = write.unnamed.length
         ? ` ${write.unnamed[0]} is new and has no line yet — the listing shows its first fact instead. Call again with \`description\` (one line about what it is) and \`aliases\` (the names they say for it).`
@@ -265,59 +266,61 @@ export const createMemoryTools = (
     },
   }),
 
-  [TOOL_NAMES.memory_show]: tool({
-    description: `Put a note on the user's screen so they can see it while you
-talk about it, and take it away again. They cannot edit it there — they say
-what to drop and you drop it.`,
-    inputSchema: z.object({
-      path: z
-        .string()
-        .nullable()
-        .describe(
-          "The note to put on screen, exactly as the listing writes it. Null takes it away.",
-        ),
-    }),
-    execute: async ({ path }) => {
-      if (!path?.trim()) {
-        appEvents.emit({ type: "memory-view", path: null });
-        return { note: "Taken off the screen." };
-      }
-      // The screen gets only the path and reads facts over GET, so deletions show up on their own
-      const { notes } = await readNotes([path], { touch: false });
-      const note = notes[0];
-      if (!note) {
-        return { note: `Nothing on the listing called ${path.trim()}.` };
-      }
-      appEvents.emit({ type: "memory-view", path: note.path });
-      return {
-        ...note,
-        note: "It is on their screen now, in this order. Ask what they no longer need, and forget only what they name.",
-      };
-    },
-  }),
-
   [TOOL_NAMES.memory_forget]: tool({
-    description: "Delete one fact for good.",
+    description: "Delete facts for good.",
     inputSchema: z.object({
-      factId: z
+      factIds: z
         .number()
         .int()
-        .describe("The id that came with the fact when the note was opened."),
+        .array()
+        .min(1)
+        .describe(
+          "The ids that came with the facts when their notes were opened — every one to delete, in one call.",
+        ),
     }),
-    execute: async ({ factId }) => {
-      const forgotten = await forgetFactById(factId);
-      if (!forgotten) {
-        return { note: `No fact with id ${factId}. Nothing was deleted.` };
+    execute: async ({ factIds }) => {
+      const missing: number[] = [];
+      /** Notes that lost their last fact, and went with it (memory.query forgetFactById). */
+      const gone: string[] = [];
+      /** Notes that still hold something, handed back as they are now. */
+      const left = new Set<string>();
+      for (const id of new Set(factIds)) {
+        const forgotten = await forgetFactById(id);
+        if (!forgotten) {
+          missing.push(id);
+          continue;
+        }
+        if (forgotten.noteGone) {
+          left.delete(forgotten.path);
+          gone.push(forgotten.path);
+        } else {
+          left.add(forgotten.path);
+        }
       }
 
-      // The note goes with its last fact; the listing still shows it until the next session, so say so
-      if (forgotten.noteGone) {
+      if (!gone.length && !left.size) {
         return {
-          note: `${GONE} That was the last fact under ${forgotten.path}, so the note went with it.`,
+          note: `No fact with id ${missing.join(", ")}. Nothing was deleted.`,
         };
       }
-      const { notes } = await readNotes([forgotten.path], { touch: false });
-      return { ...notes[0], note: GONE };
+
+      // The notes that went are still on the listing until the next session, so say so
+      const said = [
+        GONE,
+        gone.length === 1
+          ? `That was the last fact under ${gone[0]}, so the note went with it.`
+          : gone.length
+            ? `That was the last of ${gone.join(", ")}, so those notes went with them.`
+            : "",
+        missing.length
+          ? `No fact with id ${missing.join(", ")}, so those were skipped.`
+          : "",
+      ]
+        .filter(Boolean)
+        .join(" ");
+      if (!left.size) return { note: said };
+      const { notes } = await readNotes([...left], { touch: false });
+      return { notes: notes.map(withCount), note: said };
     },
   }),
 });