thursday-agent 0.3.0 → 0.4.0

package/features/ai/chatgpt.ts

@@ -1,5 +1,5 @@
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { createServer, type Server } from "node:http";
+import { createServer, type RequestListener, type Server } from "node:http";
 import { createOpenAI } from "@ai-sdk/openai";
 import { type LanguageModel, wrapLanguageModel } from "ai";
 import { formatDistanceToNowStrict } from "date-fns";
@@ -28,6 +28,12 @@ const TOKEN_URL = "https://auth.openai.com/oauth/token";
 /** The only redirect registered for that client, so the answer comes back to this port and no other. */
 const CALLBACK_PORT = 1455;
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}/auth/callback`;
+/**
+ * Both loopbacks: `localhost` in the browser reaches whichever answers first, and an
+ * address bound here outranks another app's `::` or `0.0.0.0` on the same port — so the
+ * answer cannot land in someone else's server.
+ */
+const CALLBACK_HOSTS = ["127.0.0.1", "::1"];
 const SCOPE = "openid profile email offline_access";
 const CODEX_URL = "https://chatgpt.com/backend-api/codex";
 /** The access token's claim naming the account and its plan. */
@@ -51,11 +57,11 @@ const SignInSchema = z.object({
 type SignIn = z.infer<typeof SignInSchema>;
 
 type Pinned = {
-  __chatgptListener?: Server | null;
+  __chatgptListeners?: Server[] | null;
   __chatgptRenewal?: ReturnType<typeof createKeyedLock>;
 };
 
-/** Pinned to globalThis: next dev reloads this module, and the listener holding the port and the renewal lane must be the originals. */
+/** Pinned to globalThis: next dev reloads this module, and the listeners holding the port and the renewal lane must be the originals. */
 const pinned = globalThis as Pinned;
 
 /**
@@ -74,7 +80,8 @@ export async function startChatGptSignIn(): Promise<string> {
   const verifier = randomBytes(32).toString("base64url");
   const state = randomBytes(16).toString("hex");
 
-  const server = createServer((request, response) => {
+  const servers: Server[] = [];
+  const answer: RequestListener = (request, response) => {
     void answerCallback(request.url ?? "/", { state, verifier }).then(
       (page) => {
         response.writeHead(page.status, {
@@ -85,29 +92,42 @@ export async function startChatGptSignIn(): Promise<string> {
             autoClose: page.status === 200,
           }),
           () => {
-            if (page.last && pinned.__chatgptListener === server) {
+            if (page.last && pinned.__chatgptListeners === servers) {
               stopListening();
             }
           },
         );
       },
     );
-  });
+  };
 
-  await new Promise<void>((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(CALLBACK_PORT, "127.0.0.1", () => resolve());
-  }).catch((cause: NodeJS.ErrnoException) => {
+  for (const host of CALLBACK_HOSTS) {
+    const server = createServer(answer);
+    const failure = await new Promise<NodeJS.ErrnoException | null>(
+      (resolve) => {
+        server.once("error", resolve);
+        server.listen(CALLBACK_PORT, host, () => resolve(null));
+      },
+    );
+    if (!failure) {
+      servers.push(server);
+      continue;
+    }
+    // No IPv6 on this machine: nobody else can answer there either
+    if (failure.code === "EADDRNOTAVAIL" || failure.code === "EAFNOSUPPORT") {
+      continue;
+    }
+    for (const bound of servers) bound.close();
     publicError(
-      cause.code === "EADDRINUSE"
-        ? `Port ${CALLBACK_PORT} is in use — another ChatGPT or Codex sign-in is waiting. Finish or close it, then try again.`
-        : `Could not wait for the sign-in: ${errorToString(cause)}`,
+      failure.code === "EADDRINUSE"
+        ? `Port ${CALLBACK_PORT} is in use by another app — often a ChatGPT or Codex sign-in still waiting. Finish or close it, then try again.`
+        : `Could not wait for the sign-in: ${errorToString(failure)}`,
     );
-  });
-  pinned.__chatgptListener = server;
+  }
+  pinned.__chatgptListeners = servers;
   // A page nobody finishes must not hold the port for the life of the process
   setTimeout(() => {
-    if (pinned.__chatgptListener === server) stopListening();
+    if (pinned.__chatgptListeners === servers) stopListening();
   }, CHATGPT_SIGN_IN.waitMs).unref();
 
   const url = new URL(AUTHORIZE_URL);
@@ -128,10 +148,12 @@ export async function startChatGptSignIn(): Promise<string> {
 }
 
 function stopListening() {
-  const server = pinned.__chatgptListener;
-  pinned.__chatgptListener = null;
-  server?.close();
-  server?.closeIdleConnections();
+  const servers = pinned.__chatgptListeners;
+  pinned.__chatgptListeners = null;
+  for (const server of servers ?? []) {
+    server.close();
+    server.closeIdleConnections();
+  }
 }
 
 type CallbackPage = {

package/features/ai/load-tools.ts

@@ -1,8 +1,8 @@
 import { asSchema, type ToolSet, tool } from "ai";
 import { formatDistanceToNowStrict } from "date-fns";
-import { IS_DEV } from "@/config";
+import { CALL_EXEC_TIMEOUT_MS, IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
-import { clockNow, tidying } from "@/features/ai/prompts/prompt-helper";
+import { clockNow } from "@/features/ai/prompts/prompt-helper";
 import {
   answerTool,
   askThursdayTool,
@@ -17,7 +17,6 @@ import { createSkillTools } from "@/features/ai/tools/skills.tool";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { createWorkspaceTools } from "@/features/ai/tools/workspace.tool";
 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";
@@ -30,8 +29,8 @@ import { clip } from "@/lib/utils";
  * Which tools each runtime is handed; what it is told about them is the prompt's job.
  * Every tool runs on the server, including calls made during a voice session; only `end_call`
  * has no execute (the page hangs up). The split is by time, not capability: anything that
- * presupposes waiting (MCP, studio, browser) belongs to the bot. Every runtime writes to
- * memory, but only the call gets the whole of it: revising, carrying and naming need the user there.
+ * presupposes waiting (MCP, studio, browser) belongs to the bot. Only the call and an edit on
+ * the memory screen write to memory: revising, carrying and naming need the user there. A bot reads it.
  * Skills are the one thing that crosses back, and only when asked for: the call reads one itself
  * when Settings › Thursday says so (thursday.query readCallSkillsOn).
  */
@@ -83,7 +82,13 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
 
         // The row carries the bot's own spelling, not the transcript's
         const { startTask } = await import("@/features/bot/bot.runner");
-        const id = await startTask({ bot: found.name, request, label, callId });
+        const id = await startTask({
+          bot: found.name,
+          request,
+          label,
+          callId,
+          from: "thursday",
+        });
         return {
           taskId: id,
           // The label is the handle: without it in front of her, a follow-up
@@ -182,7 +187,7 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           return { label: one.label, status: "cancelled" };
         }
         if (!answer?.trim()) return "Say what to pass on.";
-        await answerTask(one.id, answer.trim());
+        await answerTask(one.id, answer.trim(), "thursday");
         return {
           // Named even when the model named it: with no job given this is the
           // one that moved last, and saying which makes a wrong one obvious
@@ -265,9 +270,6 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
   const sandbox = await openWorkspace();
 
   if (run.target === "thursday") {
-    // memory_show only when there is something to tidy (prompt-helper tidying)
-    const { [TOOL_NAMES.memory_show]: show, ...always } = memory;
-    const { crowded, heavy } = tidying(await listNoteIndex());
     // Off unless switched on: a skill is a page of instructions arriving
     // mid-sentence. Switched off, the prompt does not list them as hers either
     // (thursday.prompt), so the two always say the same thing
@@ -276,11 +278,15 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
       : {};
 
     return {
-      ...always,
-      ...(crowded || heavy.length ? { [TOOL_NAMES.memory_show]: show } : {}),
+      ...memory,
       ...skills,
-      // The shell alone. A whole file is a job, not a glance (workspace.tool)
-      ...createWorkspaceTools(sandbox, { write: false }),
+      // The shell alone, for no longer than a call can sit silent on it: the mic
+      // is closed while a tool runs (config CALL_EXEC_TIMEOUT_MS). A whole file is
+      // a job, not a glance (workspace.tool)
+      ...createWorkspaceTools(sandbox, {
+        write: false,
+        timeoutMs: CALL_EXEC_TIMEOUT_MS,
+      }),
       // Handing work over, following it, and hanging up belong to the voice session only
       ...createTaskTools(run.callId),
       ...CALL_TOOLS,

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}`;
 }
@@ -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.`;