thursday-agent 0.1.2 → 0.3.0

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

@@ -1,7 +1,9 @@
-import { BOT_RUN, PATHS } from "@/config";
+import type { ModelMessage } from "ai";
+import { PATHS, PROMPT_LINE, WORKSPACE_KEEP } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import { listJobBots } from "@/features/bot/bot.query";
-import type { JobBot } from "@/features/bot/bot.schema";
+import { botMemoryFolder, listBotMemory } from "@/features/bot/bot.memory";
+import { listJobBots, readBotMemoryOn } from "@/features/bot/bot.query";
+import type { BotMemory, JobBot } from "@/features/bot/bot.schema";
 import { findPinnedTools } from "@/features/connectors/mcp.query";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
 import {
@@ -16,13 +18,18 @@ import {
   loadSkills,
   type SkillMetadata,
 } from "@/features/skills/skills.discover";
-import { openWorkspace } from "@/features/workspace/workspace";
+import {
+  type MachineTools,
+  openWorkspace,
+  readMachineTools,
+} from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { clip } from "@/lib/utils";
 import { listConnectedToolNames } from "../tools/connected";
 import {
   carriedLines,
   type LoadedPrompt,
+  logPromptSize,
   mcpToolLines,
   noteLines,
   nowLine,
@@ -34,50 +41,74 @@ 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] = 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(),
-    ],
-  );
-
-  // 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,
+    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),
+  ]);
+
+  // 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(askedBy) : identity(),
+    askedBy ? borrowedIdentity(name, askedBy) : identity(name),
     memory(index, carried),
+    memoryOn ? ownMemory(botMemoryFolder(name), kept) : "",
     connectedTools(mcpTools, pinned),
     methods(skills),
-    environment(sandbox.cwd),
+    environment(sandbox.cwd, machine, folders),
     roster(peers),
     askedBy ? askingBack(askedBy) : ASKING,
-    askedBy ? handingUp(askedBy) : FINISHING,
+    askedBy ? handingUp(askedBy) : ANSWERING,
     // Last, so it is the closest thing to the work and outranks the rest
     ownerInstruction(persona),
   ]
     .filter(Boolean)
     .join("\n\n");
 
+  logPromptSize("bot", text);
   logger.debug(`bot prompt\n${text}`);
 
   return {
@@ -88,18 +119,19 @@ export async function loadBotPrompt(
 }
 
 /** Who the bot is, what machine it is on, and that guesses are not results. */
-function identity(): string {
+function identity(name: string): string {
   return [
-    `You are a worker. Thursday handed you a job while she keeps talking to the user; you are not in that conversation and never speak to the user directly. ${nowLine()}`,
+    // Named, because the owner's prompt may not name it and its own instructions are addressed to it
+    `You are ${name}, a worker. Thursday handed you a job while she keeps talking to the user — they speak to her and to nobody else, and what she says out of your answer is the only part of this that reaches them. You are not in that conversation and never address the user. This thread is drawn on their screen while you work, though: not written to them, but not private either. ${nowLine()}`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
 }
 
 /** The borrowed seat: above it is the borrowing bot, not Thursday. */
-function borrowedIdentity(askedBy: string): string {
+function borrowedIdentity(name: string, askedBy: string): string {
   return [
-    `You are a worker. ${askedBy} is holding a job Thursday handed them and has handed one part of it to you. You never speak to the user: ${askedBy} reports, and what you hand back goes into their report as-is. ${nowLine()}`,
+    `You are ${name}, a worker. ${askedBy} has handed you one part of a job Thursday handed over; your first message says who holds it and how it reached you. The user speaks to Thursday and to nobody else; you never address them, and what you hand back goes into ${askedBy}'s answer as-is. This thread is drawn on their screen while you work: not written to them, but not private either. ${nowLine()}`,
     MACHINE,
     NO_GUESSING,
   ].join("\n\n");
@@ -107,7 +139,7 @@ function borrowedIdentity(askedBy: string): string {
 
 const MACHINE = `**You are on a real computer — the user's own.** You have a shell and a filesystem, and the job is done, not described: where there is no tool for something, write one — in \`node\` unless they asked for another language, the runtime this app itself runs on. Reach for \`${TOOL_NAMES.bash}\` before concluding that something cannot be done, but after the roster, not instead of it: a script you write to do another bot's job is the long way round.
 
-**What is missing gets installed.** Inside the workspace, freely; onto the machine itself — \`python3\`, a \`brew\` package — once they say yes, so ask. What is already there is nobody's question.
+**What is missing gets installed**, onto the machine once they say yes. What is already there is nobody's question — Environment says what this machine has.
 
 **Bring back the thing itself** — their own machine, their own accounts, their own copy of whatever they sent you for — not a smaller safer version of it, and not a note on why you did not.`;
 
@@ -127,14 +159,14 @@ Written by the person this bot works for. Where these and anything above disagre
 ${persona.trim()}`
     : "";
 
-/** A bot reads memory and adds to it; revising and naming are the call's (load-tools), so the chapter is that small. */
+/** A bot only reads memory; every write, revising and the names the user says are the call's (load-tools), so the chapter is that small. */
 function memory(
   index: MemoryIndexEntry[],
   carried: MemoryAlwaysLoaded[],
 ): string {
-  const head = `## Memory
+  const head = `## The user's memory
 
-What the user's assistant knows about them — yours to read, and to add to when the work turns up something about them that outlives the job. What the job itself turned up goes in your report. It describes the user, not you: how they are named and spoken to is hers to use with them, not yours to borrow.`;
+What 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:
@@ -151,6 +183,34 @@ A topic not listed is one nobody knows anything about.`;
   return [head, alreadyKnown, listing].filter(Boolean).join("\n\n");
 }
 
+/**
+ * The bot's own memory (features/bot/bot.memory), listed by each file's first line so what a
+ * file holds costs one line until a job opens it. Always drawn, so a first job knows it has one.
+ * Nothing says what usually goes in first: a line like that is what a first job writes, whether
+ * or not the job taught it anything.
+ */
+function ownMemory(folder: string, kept: BotMemory): string {
+  const listing = kept.entries.length
+    ? kept.entries
+        .map(({ file, line }) =>
+          line
+            ? `- ${file} — ${clip(line, PROMPT_LINE.botMemory)}`
+            : `- ${file}`,
+        )
+        .join("\n")
+    : "Empty.";
+  const rest =
+    kept.total > kept.entries.length
+      ? `\n\nThe newest ${kept.entries.length} of ${kept.total}; \`ls ${folder}\` for the rest.`
+      : "";
+
+  return `## Your memory
+
+What you kept from your own earlier jobs, in \`${folder}/\`: one topic per file, its first line saying what it holds, read by no other bot. Keep what a later job would otherwise have to find out again — how a site signs in, the way through its screens, a command that turned out right — and fix or delete a file that proved wrong. No passwords, keys or codes.
+
+${listing}${rest}`;
+}
+
 /**
  * Names only; schemas stay behind `tool_search`. Without the list the model cannot tell
  * "no such tool" from "not searched yet".
@@ -184,13 +244,35 @@ Written-down methods. When the job is one of these, read it with \`${TOOL_NAMES.
 ${skillLines(skills)}`;
 }
 
-/** Names the three workspace folders once; `write_file` refuses anything else (workspace.ts writeRefusal). */
-const environment = (cwd: string) => `## Environment
+/**
+ * The machine, then the workspace. What is installed is read as the prompt is
+ * assembled (workspace.ts readMachineTools) rather than left to the job to find
+ * out: a bot that has to check first spends a step on it, and one that guesses
+ * writes for a runtime that is not here. Naming what is absent does as much
+ * work as naming what is present — it is the half a model otherwise assumes.
+ * The three folders are named once; `write_file` refuses anything else
+ * (workspace.ts writeRefusal).
+ */
+const environment = (
+  cwd: string,
+  machine: MachineTools,
+  folders?: { scratch: string | null; own: string },
+) => `## Environment
 
 Current Cwd: ${cwd}
 Platform: ${process.platform}
+${machineLines(machine)}
 
-Your workspace — \`${TOOL_NAMES.bash}\` runs here. Everything you write goes in one of three folders: \`${PATHS.artifacts}/\` (finished work the user opens), \`${PATHS.projects}/\` (code you build), \`${PATHS.scratch}/\` (everything in progress). Never the directory above — that is the app you run in; outside the workspace, only where the user pointed you.`;
+Read off this machine as the job opened, so it is current: reach for what is here instead of checking for it.
+
+Your workspace — \`${TOOL_NAMES.bash}\` runs here. Everything you write goes in one of these, and they are kept apart because what is in them lives for different lengths of time:
+
+- \`${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, 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.`;
 
 /** Same roster the voice prompt shows, used the other way: which part of a held job is another bot's. */
 function roster(peers: JobBot[]): string {
@@ -200,63 +282,167 @@ function roster(peers: JobBot[]): string {
 
 ${peers.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}
 
-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.`;
+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. What you were handed stays yours and you answer for it. They get the job, the call it came from and what you write them — not this thread.`;
 }
 
-/** The only place a run can stop. The user's request to buy, pay or top up is itself the go-ahead. */
+/** The only place a run can stop. */
 const ASKING = `## Asking
 
 What you cannot get for yourself — a decision between real options, a detail only the conversation has, a go-ahead before deleting or sending — goes to \`${TOOL_NAMES.ask_thursday}\`, once, with everything in it. Ask before you start, not after an hour; never ask what one command would tell you.
 
 A job that arrives without its shape — several ways to do it, no telling what it is for, a scale nobody named — is planned before it is built: put the plan up in two or three lines with what you need decided. A job asked for as one thing is built, not proposed.
 
-A request that says buy, pay, top up is the go-ahead — press the button. Only what is theirs alone stops the job: a password, a one-time code, a passkey, a permission on their machine. Set it up one action away, ask, and carry on when the answer comes back.`;
+Only what is theirs alone stops the job: a password, a one-time code, a passkey, a permission on their machine. Set it up one action away, ask, and carry on when the answer comes back.`;
 
 const askingBack = (askedBy: string) => `## Asking
 
 What you cannot get for yourself goes to \`${TOOL_NAMES.ask_back}\`: ${askedBy} handed you this part and answers from what they have. They cannot take a question to the user, so for what is the user's alone take the safer reading and say so in what you hand back. Ask before you start, once, whole.`;
 
-const STEP_CAP = `Your steps are capped at ${BOT_RUN.steps}; running long, report what you have with \`complete: false\` while the summary is still yours to write.`;
-
 /**
- * The job ends in the thing that was asked for; no prescribed document shape.
+ * An answer is sized by the request, not by the shape of a document: this is where
+ * the only upper bound on a run is stated, and the one place that says the spoken
+ * line is hers to compose. Nothing here asks for a script — a bot that writes to be
+ * heard writes for a length rather than for a question, and the padding it adds to
+ * reach that length is steps, not words.
+ * The step cap is stated nowhere a bot reads: told the number, runs work to it. It is
+ * enforced where it cannot be argued with (bot.run `stepCountIs`, and `lastStep`).
  * Images in `.md` need absolute routes because a document opens from two places and relative paths resolve differently.
  */
-const FINISHING = `## Finishing
+const ANSWERING = `## Answering
 
-Every job ends with \`${TOOL_NAMES.report}\`, in the user's language, written to be heard — she reads it out loud. **The job ends in the thing that was asked for**: an action with the action done, photos in a page with the photos in it, a comparison in a table. Anything that does not fit in a few lines is a file under \`${PATHS.artifacts}/\`, and the report names its path — it becomes a link on their screen. In a \`.md\`, images only by absolute route (\`/api/file/${PATHS.artifacts}/…\`).
+Every job ends with \`${TOOL_NAMES.answer}\`. **Answer what was asked, at the size it was asked**: a question ends in its answer — one number is one line — and a thing to make comes back made, an action done, photos in a page, a comparison in a table. Once you have what they asked for the job is done; the next thing you would go and check is theirs to ask for.
 
-\`complete: false\` when part of the request is genuinely undone — say where you got to and the user decides. ${STEP_CAP}`;
+You are answering Thursday, not the user: she is on the call and picks what to say out of this. Write it plainly, in the user's language — the thread is on their screen as you write it. Anything past a few lines is a file under \`${PATHS.artifacts}/\`, and the answer names its path — it becomes a link on their screen. In a \`.md\`, images only by absolute route (\`/api/file/${PATHS.artifacts}/…\`).`;
 
-const handingUp = (askedBy: string) => `## Finishing
+const handingUp = (askedBy: string) => `## Answering
 
-Every part ends with \`${TOOL_NAMES.report}\`; what you hand back goes into ${askedBy}'s own report. Hand back what the brief asked for, in the shape it asked for, with everything you learned that bears on it — exact values, the paths of files you wrote, what did not work. They cannot see your thread, so long is right here. \`complete: false\` when part of the brief is undone, with where you got to. ${STEP_CAP}`;
+Every part ends with \`${TOOL_NAMES.answer}\`; what you hand back goes into ${askedBy}'s own answer. Hand back what the brief asked for, in the shape it asked for, with everything you learned that bears on it — exact values, the paths of files you wrote, what did not work. They cannot see your thread, so long is right here.`;
 
 /** How many turns of the call travel with the job: enough for one missed detail, not enough to bury the request. */
 export const OPENING_TURNS = 10;
-const OPENING_TURN_CHARS = 160;
+
+/** A user message's content; every seat's first message is two text parts (buildTaskOpening). */
+export type OpeningContent = Extract<ModelMessage, { role: "user" }>["content"];
 
 /**
- * The first message a bot reads: the request plus the last turns of the call, verbatim.
- * The request is one sentence the realtime model produced; a detail the user said may only be here.
- * Stored as the thread's first row (seq 0) so it survives a resume (bot.runner).
+ * The first message of the bot holding a job, stored as the thread's first row
+ * (seq 0, bot.runner startTask) and read whole on every resume and after every
+ * compaction. Two text parts: who is who on this job, then the chain — the job
+ * as Thursday handed it and the call it came from, verbatim, because the request
+ * is one sentence the realtime model produced and a detail the user said may
+ * only be in the call. The chain is what a borrowed bot inherits (buildHandoff),
+ * so its headings name people and never say "you".
  */
 export function buildTaskOpening(input: {
+  bot: string;
   request: string;
   conversation: { role: "user" | "assistant"; text: string }[];
-}): string {
+}): OpeningContent {
   const turns = input.conversation.filter((turn) => turn.text.trim());
-  if (!turns.length) return input.request;
+  const job = `## Thursday → ${input.bot}: the job\n\n${input.request.trim()}`;
+  const call = turns.length
+    ? `## The call the job came from — its last ${turns.length} turns, verbatim
+
+A detail missing from the job may be here — a name, a number, which of two. Where the two disagree the job wins, unless they asked out loud for something to be done and the job only asks about it: then the doing is the job.
 
-  const lines = turns.map(
+${turns
+  .map(
     (turn) =>
-      `${turn.role === "user" ? "user" : "thursday"}: ${clip(turn.text, OPENING_TURN_CHARS)}`,
-  );
-  return `${input.request}
+      `${turn.role === "user" ? "user" : "thursday"}: ${clip(turn.text, PROMPT_LINE.callTurn)}`,
+  )
+  .join("\n")}`
+    : "";
+  return [
+    { type: "text", text: whoIsWho([input.bot]) },
+    { type: "text", text: [job, call].filter(Boolean).join("\n\n") },
+  ];
+}
 
-## The call, just before this reached you
+/**
+ * The first message of a borrowed bot, built by the bot that borrows it (bot.run
+ * `ask_bot`) and never stored: the chain it inherits, copied as it is, then what
+ * the borrowing bot has done and the part it hands over. `bots` runs from the
+ * bot holding the job down to this one, so each hand-off adds one name and two
+ * sections and every seat reads the same shape.
+ */
+export function buildHandoff(input: {
+  chain: string;
+  bots: string[];
+  did: string | null;
+  part: string;
+}): OpeningContent {
+  const to = input.bots.at(-1) ?? "";
+  const from = input.bots.at(-2) ?? "";
+  const did = input.did?.trim()
+    ? `## ${from} → ${to}: what ${from} has done, and why this part is ${to}'s\n\n${input.did.trim()}`
+    : "";
+  const part = `## ${from} → ${to}: the part\n\n${input.part.trim()}`;
+  return [
+    { type: "text", text: whoIsWho(input.bots) },
+    {
+      type: "text",
+      text: [input.chain, did, part].filter(Boolean).join("\n\n"),
+    },
+  ];
+}
 
-A detail that is not in the request may be here — a name, a number, which one of two. The request wins where they disagree, with one exception: when they asked out loud for something to be *done* and the request only asks about it, the doing is the job.
+/**
+ * The chain out of a seat's first message, for the next hand-off. A thread
+ * opened before the two-part shape has its opening as one string, which is the
+ * whole chain there was.
+ */
+export function chainOf(first: ModelMessage | undefined): string {
+  if (first?.role !== "user") return "";
+  if (typeof first.content === "string") return first.content;
+  const texts = first.content.flatMap((part) =>
+    part.type === "text" ? [part.text] : [],
+  );
+  return texts.at(-1) ?? "";
+}
 
+/** Who is who on this job; the last of `bots` is the one reading it. */
+function whoIsWho(bots: string[]): string {
+  const you = bots.length - 1;
+  const lines = bots.map((bot, index) => {
+    if (index === 0) {
+      return index === you
+        ? `- **${bot} (you)** — Thursday handed you this job. You answer to Thursday, and your answer is the only part of it that reaches the user.`
+        : `- **${bot}** — holds the job Thursday handed over, and answers for it.`;
+    }
+    const from = bots[index - 1];
+    return index === you
+      ? `- **${bot} (you)** — ${from} handed you one part of it: the last section below. You answer to ${from}; nobody else hears from you.`
+      : `- **${bot}** — ${from} handed them one part of it.`;
+  });
+  return `## Who is who on this job
+
+- **The user** — talks only to Thursday, on a voice call. No bot addresses them.
+- **Thursday** — the user's assistant on that call. Hands jobs to bots and tells the user what comes back.
 ${lines.join("\n")}`;
 }
+
+/** One line per kind, absences included. Only a bot gets these: the call runs one command as a glance. */
+function machineLines(machine: MachineTools): string {
+  const line = (label: string, of: MachineTools["runtimes"]) =>
+    `${label}: ${of.found.length ? of.found.join(", ") : "none"}.${
+      of.missing.length ? ` Not here: ${of.missing.join(", ")}.` : ""
+    }`;
+  // Not a preference: openWorkspace writes the pnpm fence, and an `npm install`
+  // in a project here resolves against that rather than against the project
+  const fenced = machine.managers.found.includes("pnpm")
+    ? " Use pnpm, not npm — this workspace is fenced for it (`pnpm-workspace.yaml`, `.npmrc`)."
+    : "";
+  return [
+    line("Runtimes", machine.runtimes),
+    `${line("Package managers", machine.managers)}${fenced}`,
+    machine.browser === null
+      ? ""
+      : machine.browser
+        ? "Browser: installed."
+        : "Browser: not installed — `playwright-cli install-browser chromium` puts one there.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}

package/features/ai/prompts/memory-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,15 +1,16 @@
 import { format, formatDistanceToNowStrict } from "date-fns";
-import { MEMORY_LISTING_TOKENS, 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 { estimateTokens } from "@/lib/tokens";
+import { logger } from "@/lib/logger";
+import { estimateTokens, sectionTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
 
 /**
@@ -26,12 +27,67 @@ export type LoadedPrompt = {
   opening: string | null;
 };
 
-/** `**Now**: 2026-09-02 (Wed) 15:41 Asia/Seoul` */
-export const nowLine = (now = new Date()) =>
-  `**Now**: ${format(now, "yyyy-MM-dd (EEE) HH:mm")} ${
+/**
+ * What one assembled prompt costs, said where it is assembled. The debug line is
+ * the whole breakdown; past PROMPT_BUDGET it is a warning naming the chapter
+ * carrying it, and that one is always a listing the user can act on — nothing
+ * else in the app would ever say a prompt had grown.
+ */
+export function logPromptSize(kind: string, text: string): void {
+  const parts = sectionTokens(text);
+  const total = parts.reduce((sum, part) => sum + part.tokens, 0);
+  logger.debug(
+    `${kind} prompt ${total} tokens — ${parts
+      .map((part) => `${part.name} ${part.tokens}`)
+      .join(", ")}`,
+  );
+  const biggest = parts[0];
+  if (total > PROMPT_BUDGET && biggest) {
+    logger.warn(
+      `${kind} prompt is ${total} tokens, over ${PROMPT_BUDGET}: ${biggest.name} carries ${biggest.tokens} of it. Every call and every job pays this.`,
+    );
+  }
+}
+
+/** `2026-09-02 (Wed) 15:41 Asia/Seoul` */
+export const clockNow = (now = new Date()) =>
+  `${format(now, "yyyy-MM-dd (EEE) HH:mm")} ${
     Intl.DateTimeFormat().resolvedOptions().timeZone
   }`;
 
+/** `**Now**: 2026-09-02 (Wed) 15:41 Asia/Seoul` */
+export const nowLine = (now = new Date()) => `**Now**: ${clockNow(now)}`;
+
+/**
+ * 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);
@@ -59,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. */
@@ -132,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
@@ -147,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--) {
@@ -185,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);
   }