thursday-agent 0.2.0 → 0.4.0

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

@@ -1,21 +1,14 @@
-import { BOT_NOTES, BOT_RUN, PATHS } from "@/config";
+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 {
-  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, 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,
@@ -25,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,
@@ -43,60 +36,58 @@ 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 [
-    skills,
-    index,
-    carried,
-    mcpTools,
-    pinned,
-    allBots,
-    ownNote,
-    notesOn,
-    machine,
-  ] = await Promise.all([
-    loadSkills(sandbox),
-    listNoteIndex(),
-    listAlwaysLoaded(),
-    // User-connected servers and the app's studio in one list (tools/connected)
-    listConnectedToolNames(),
-    // MCP tools this bot already holds; dropped from the listing below
-    findPinnedTools(name),
-    listJobBots(),
-    // What this bot left itself; kept by the pass that runs after a job (bot.notes)
-    readBotNote(name),
-    readBotNotesOn(),
-    // One `command -v` sweep; what is here decides the first command (environment)
-    readMachineTools(sandbox),
-  ]);
-
-  // Drop self so a bot cannot call itself; a borrowed bot has no roster at all (bot.run MAX_DEPTH)
-  const peers = askedBy ? [] : allBots.filter((bot) => bot.name !== name);
+  const askedBy = seat?.askedBy ?? null;
+  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)
+  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) : "",
+    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) : FINISHING,
+    askedBy ? handingUp(askedBy) : ANSWERING,
     // Last, so it is the closest thing to the work and outranks the rest
     ownerInstruction(persona),
   ]
@@ -113,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 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}, 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} 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}, 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");
@@ -154,48 +162,46 @@ 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. */
-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.
-
-Yours to read, and to add to when the work turns up something about *them* that outlives the job; what the job itself turned up goes in your report. It describes the user, not you: how they are named and spoken to is hers to use with them, not yours to borrow. What you learn about this machine is not memory — that is your own instructions, below.`;
-
-  const alreadyKnown = carried.length
-    ? `Already known:
-
-${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 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 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 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, at }) => {
+          const said = line ? ` — ${clip(line, PROMPT_LINE.botMemory)}` : "";
+          return `- ${file}${said} · ${format(toDate(at), "yyyy-MM-dd")}`;
+        })
+        .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}/\` 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}`;
 }
 
 /**
@@ -256,8 +262,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,63 +277,150 @@ ${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 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 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 }[];
-}): 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());
-  if (!turns.length) return input.request;
+  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
+
+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], input.from) },
+    { 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) ?? "";
+}
+
+/**
+ * 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)** — ${
+            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 by = bots[index - 1];
+    return index === you
+      ? `- **${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 on this job
 
 ${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);
   }