thursday-agent 0.5.0 → 0.7.0

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

@@ -1,10 +1,19 @@
 import type { ModelMessage } from "ai";
 import { format } from "date-fns";
-import { PATHS, PROMPT_LINE, WORKSPACE_KEEP } from "@/config";
+import {
+  BOT_MEMORY_LIMITS,
+  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, TaskSpeaker } from "@/features/bot/bot.schema";
+import type {
+  BotMemory,
+  JobBot,
+  ThreadSpeaker,
+} from "@/features/bot/bot.schema";
 import { findPinnedTools } from "@/features/connectors/mcp.query";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
 import { listNoteIndex } from "@/features/memory/memory.query";
@@ -23,7 +32,6 @@ import { logger } from "@/lib/logger";
 import { clip } from "@/lib/utils";
 import { listConnectedToolNames } from "../tools/connected";
 import {
-  type LoadedPrompt,
   logPromptSize,
   mcpToolLines,
   noteLines,
@@ -31,27 +39,19 @@ import {
   skillLines,
 } from "./prompt-helper";
 
-/**
- * Everything a bot hears. One chapter per function or const; the loader is the table of contents.
- * 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 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 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.
- */
+/** Where this turn sits: who coordinates the thread, who is asking, and the exchange it answers. */
+type Seat = { owner: string; caller: string; messageId: string | null };
+
+/** Assemble this participant's instructions and current return route on every turn. */
 export async function loadBotPrompt(
   self: string,
   persona?: 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> {
+  seat?: Seat | null,
+  /** This run's folders: the job's, the bot's own, and where its finished work goes (bot.run). */
+  folders?: { scratch: string | null; own: string; artifacts: string },
+): Promise<{ text: string }> {
   const sandbox = await openWorkspace();
   const name = self.trim();
-  const askedBy = seat?.askedBy ?? null;
   const [skills, index, mcpTools, pinned, allBots, kept, memoryOn, machine] =
     await Promise.all([
       loadSkills(sandbox),
@@ -68,17 +68,10 @@ export async function loadBotPrompt(
       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 peers = allBots.filter((bot) => bot.name !== name);
 
   const text = [
-    askedBy ? borrowedIdentity(name, askedBy) : identity(name),
+    identity(name, seat),
     memory(index),
     connectedTools(mcpTools, pinned),
     methods(skills),
@@ -86,8 +79,7 @@ export async function loadBotPrompt(
     // 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,
+    collaboration(name, seat),
     // Last, so it is the closest thing to the work and outranks the rest
     ownerInstruction(persona),
   ]
@@ -97,56 +89,35 @@ export async function loadBotPrompt(
   logPromptSize("bot", text);
   logger.debug(`bot prompt\n${text}`);
 
-  return {
-    text,
-    peers: peers.map((bot) => bot.name),
-    opening: null,
-  };
+  return { text };
 }
 
 /**
- * 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.
+ * Who is who, how the job gets done, and that guesses are not results. The people come
+ * first so the rest — whose memory, who reads the answer — has someone to refer to. How
+ * this job reached it is the first message's to say (buildThreadOpening).
  */
-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}, 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: between it and Thursday is the bot that borrowed it. */
-function borrowedIdentity(name: string, askedBy: string): string {
-  return [
-    `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");
-}
+function identity(name: string, seat?: Seat | null): string {
+  const owner = seat?.owner ?? name;
+  const coordinator =
+    owner === name
+      ? "**You** coordinate this thread: its result goes from you to Thursday."
+      : `**${owner}** coordinates this thread and brings its result to Thursday.`;
+  const current = seat
+    ? `\n\nCurrent conversation: ${seat.caller} → ${name}. Your final text goes back to ${seat.caller}. Message ID: ${seat.messageId ?? "initial request"}.`
+    : "";
 
-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.
+  return `You are ${name}, one of the bots in this thread. ${nowLine()}
 
-**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.
+- **The user** — the one person all of this is for. They talk with Thursday by voice and follow this thread on their screen.
+- **Thursday** — their personal assistant. She talks with them, hands bots the work that takes time, and tells them what comes back.
+- ${coordinator}
+- **Everyone on it** keeps their own work and conversation; the others see only the messages sent to them.${current}
 
-**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.`;
+**The job is done, not described.** You are on the user's own computer, with a shell, files and the web, and how you get there is yours: when one way fails, try another; where no tool exists, write one — \`node\` is always here. Before deciding something cannot be done, look at what you have — your tools, the other bots, this machine. Bring back the thing itself — their account, their file, the real result — not a smaller, safer stand-in, and not a note on why not.
 
-const NO_GUESSING = `**Never present a guess as a result.** She says it out loud as fact. Say which part is unverified and why.`;
+**Never present a guess as a result.** Thursday says what you return out loud, as fact: say which part is unverified and why.`;
+}
 
 /**
  * What the owner wrote about this bot in settings. Carries the sentence that
@@ -170,7 +141,7 @@ ${persona.trim()}`
 function memory(index: MemoryIndexEntry[]): string {
   return `## Thursday's memory of the user
 
-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.
+What Thursday keeps from talking with them. When the job needs something about them, open the note with \`${TOOL_NAMES.memory_recall}\`; a fact marked \`said\` came from a call, and \`${TOOL_NAMES.memory_conversation}\` opens that call. What you learn about them goes in your answer — Thursday decides what to keep.
 
 path — what is under it (facts) "what the user calls it"
 
@@ -181,7 +152,8 @@ ${noteLines(index)}`;
  * 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.
+ * line like that is what a first job writes, whether or not the job taught it anything. The
+ * limits are said as a size only; a write past them is undone by the tools (bot.memory).
  */
 function ownMemory(folder: string, kept: BotMemory): string {
   const listing = kept.entries.length
@@ -199,7 +171,7 @@ function ownMemory(folder: string, kept: BotMemory): string {
 
   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.
+What you learned on your own earlier jobs, in \`${folder}/\`: one topic per file, its first line saying what it holds, read by no other bot, up to ${BOT_MEMORY_LIMITS.files} files of ${BOT_MEMORY_LIMITS.chars.toLocaleString("en-US")} characters each. It is how you get better at this work. When a job teaches you something a later one would otherwise find out again — how a site signs in, the way through its screens, a command that turned out right — or the user asks you to remember how to work, keep it with the date it was true, and fix or delete what proved wrong. No passwords, keys or codes.
 
 ${listing}${rest}`;
 }
@@ -216,7 +188,7 @@ function connectedTools(tools: McpToolRef[], pinned: McpToolRef[]): string {
   if (unheld.length === 0) return "";
 
   const pinnedNote = held.size
-    ? ` What is not listed above you are already holding — it is in your tools.`
+    ? " The ones you already hold are in your tools instead."
     : "";
 
   return `## Connected tools
@@ -226,13 +198,13 @@ ${mcpToolLines(unheld)}
 Names only: \`${TOOL_NAMES.tool_search}\` returns what each one takes, \`${TOOL_NAMES.tool_call}\` runs one.${pinnedNote}`;
 }
 
-/** Full skill descriptions (the voice prompt shows only the first sentence). */
+/** Full skill descriptions: the description is what makes a skill the right one to open (the call shows only the first sentence). */
 function methods(skills: SkillMetadata[]): string {
   if (skills.length === 0) return "";
 
   return `## Skills
 
-Written-down methods. Use the instructions already in your conversation. When the job needs a skill whose full instructions are absent, read it with \`${TOOL_NAMES.load_skill}\` before starting.
+Written-down ways of doing things. Open one with \`${TOOL_NAMES.load_skill}\` before a job it covers, unless its instructions are already in your conversation.
 
 ${skillLines(skills)}`;
 }
@@ -243,31 +215,32 @@ ${skillLines(skills)}`;
  * 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
+ * Said as what is here, not a limit: a bare listing reads as the only runtimes allowed.
+ * The folders are the app's rules; `write_file` refuses anything else
  * (workspace.ts writeRefusal).
  */
 const environment = (
   cwd: string,
   machine: MachineTools,
-  folders?: { scratch: string | null; own: string },
+  folders?: { scratch: string | null; own: string; artifacts: string },
 ) => `## Environment
 
 Current Cwd: ${cwd}
 Platform: ${process.platform}
 ${machineLines(machine)}
 
-Read off this machine as the job opened, so it is current: reach for what is here instead of checking for it.
+Read off this machine as the job opened: what is already here, not the limit of what you can use.
 
-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:
+Your workspace, where \`${TOOL_NAMES.bash}\` runs. Everything you write goes in one of these folders, 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.
+- \`${folders?.artifacts ?? 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 its dependencies install inside it, never at the workspace root.
+- \`${folders?.scratch ?? PATHS.scratch}/\` — this job's working material, shared by every bot on it; cleared ${Math.round(WORKSPACE_KEEP.forMs / 86_400_000)} days after the job ends.
+- \`${folders?.own ?? PATHS.bots}/\` — yours across every job you run here: what you keep for next time.
 
-Never the directory above — that is the app you run in; outside the workspace, only where the user pointed you.`;
+Inside the workspace, set up whatever the job needs yourself; installing anything machine-wide waits for the user's yes. Never the directory above the workspace — it is the app's, not the user's; 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. */
+/** The other bots, used the other way from the call's roster: which part of a held job is someone else's. */
 function roster(peers: JobBot[]): string {
   if (peers.length === 0) return "";
 
@@ -275,157 +248,63 @@ function roster(peers: JobBot[]): string {
 
 ${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. 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.`;
+These lines were written for the user: where one says "you", it means them. When part of the job is another bot's strength, bring it in with \`${TOOL_NAMES.send_message}\` rather than rebuilding it yourself.`;
 }
 
-/** 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.
-
-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.`;
-
 /**
- * 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.
+ * How participants reach each other. Nobody reads anyone else's transcript, so the one thing that
+ * decides whether collaboration works is what a single message carries. What the coordinator's
+ * result opens by itself is the runner's rule (file-kind opensOnFinish), said in the same terms.
  */
-const ANSWERING = `## Answering
+function collaboration(name: string, seat?: Seat | null): string {
+  const owner = (seat?.owner ?? name) === name;
+  const ending = owner
+    ? `Bring what you received together into one result for Thursday: what was done, where it is, what you decided that the request did not say, and what is still open, at the detail the user asked for. When the job ends, the first Markdown or HTML file under \`${PATHS.artifacts}/\` it names opens on the user's screen by itself; any other file opens only when they click it in the thread, so when one matters, say they can open it there.`
+    : `Your final text goes back to ${seat?.caller ?? "whoever asked"}: give them everything they need to carry on.`;
 
-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.
+  return `## Working together
 
-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}/…\`).`;
+Nobody sees your work but you, and you see only what others send you, so whatever crosses between you has to stand on its own. A request says what is wanted, what is already known or done, and where the files are; an answer gives exact values, file paths and what is still unverified. Tell whoever is waiting when something they depend on changes. End your turn when you have nothing more to do now: replies arrive as new messages and wake you.
 
-const handingUp = (askedBy: string) => `## Answering
+Ask Thursday with kind \`question\` only for a decision, permission or something only the user knows: clearly, with the context to answer, and short options when they help. Use kind \`message\` for news that needs no answer, and your final text for the result.
 
-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.`;
+${ending}
 
-/** 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;
+Write in the user's language, and name the paths of finished work. The app opens Markdown with its tables and mermaid blocks drawn, CSV as a table, HTML and PDF as pages, and images, audio and video; in Markdown, reference images by absolute route (\`/api/file/${PATHS.artifacts}/…\`).`;
+}
 
-/** A user message's content; every seat's first message is two text parts (buildTaskOpening). */
+/** A user message's content; every seat's first message is two text parts (buildThreadOpening). */
 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 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".
+ * Who handed the job over, and the job — nothing from the call it came from. The request
+ * carries what the bot needs (delegate's schema says so), and the opening outlives every
+ * compaction: a call pasted here would still be read long after, by a user talking to the
+ * bot on screen.
  */
-export function buildTaskOpening(input: {
+export function buildThreadOpening(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;
+  from: ThreadSpeaker;
 }): OpeningContent {
-  const turns = input.conversation.filter((turn) => turn.text.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
-
-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.
-
-${turns
-  .map(
-    (turn) =>
-      `${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 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"),
+      text: `You are ${input.bot}. ${by} hands you this thread${input.from === "user" ? " on screen" : " during a call"}.`,
+    },
+    {
+      type: "text",
+      text: `## ${by} → ${input.bot}: the job\n\n${input.request.trim()}`,
     },
   ];
 }
 
 /**
- * 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.
+ * One line per kind, absences included. Only a bot gets these: the call runs one command as a
+ * glance. How to install a missing browser is the browser skill's to say, not the prompt's.
  */
-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")}`;
-}
-
-/** 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"}.${
@@ -441,9 +320,7 @@ function machineLines(machine: MachineTools): string {
     `${line("Package managers", machine.managers)}${fenced}`,
     machine.browser === null
       ? ""
-      : machine.browser
-        ? "Browser: installed."
-        : "Browser: not installed — `playwright-cli install-browser chromium` puts one there.",
+      : `Browser: ${machine.browser ? "installed" : "not installed"}.`,
   ]
     .filter(Boolean)
     .join("\n");

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

@@ -0,0 +1,169 @@
+import {
+  listAlwaysLoaded,
+  listNoteIndex,
+  readNotes,
+} from "@/features/memory/memory.query";
+import {
+  MEMORY_ALWAYS_LISTED,
+  type MemoryAlwaysLoaded,
+  type MemoryIndexEntry,
+  type MemoryNoteView,
+} from "@/features/memory/memory.schema";
+import {
+  callEnding,
+  carriedLines,
+  expandedFacts,
+  logPromptSize,
+  noteLines,
+  thursdayIdentity,
+  tidying,
+} from "./prompt-helper";
+
+/**
+ * Everything the Live voice hears: who Thursday is and how a call ends (the words the backend
+ * opens with too), the guide's starter backchannel and interruption policies, a two-line
+ * delegation policy, and what she knows about the user. What the backend can do, how work is
+ * handed over, earlier calls and tidying memory are the backend's (thursday.prompt): the voice
+ * hands everything but conversation over and answers from what comes back. Assembled on every
+ * call, never cached.
+ */
+export async function loadLivePrompt(options: {
+  /** Settings › Thursday › Voice instructions; added to, never replacing, what is below. */
+  voicePrompt?: string | null;
+  locale?: string | null;
+  /** The page placed this call because background work waits on the user (call-back). */
+  calledBack?: boolean;
+}): Promise<{ text: string; opening: string }> {
+  const [carried, open, index] = await Promise.all([
+    listAlwaysLoaded(),
+    // Written out in the prompt, which is not the user asking for them: no read counted
+    readNotes(MEMORY_ALWAYS_LISTED, { touch: false }),
+    listNoteIndex(),
+  ]);
+
+  const first = !open.notes.find((note) => note.path === "profile")?.facts
+    .length;
+  // Only the first-call greeting reads it: before they have said anything, the
+  // browser's locale is the one sign of their language
+  const language = options.locale
+    ? `the language of \`${options.locale}\`, their browser's setting`
+    : "the language they use";
+
+  const text = [
+    thursdayIdentity(),
+    always(),
+    known(open.notes, carried, index),
+    first ? firstCall() : "",
+    additional(options.voicePrompt),
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+  logPromptSize("live", text);
+
+  return {
+    text,
+    // A prompt line alone does not make Live speak first; only an opening does.
+    // A call-back's opening holds no bot text: the update itself follows as commentary
+    opening: options.calledBack
+      ? "You placed this call because background work has something for the user; it comes in next. Speak first: greet them in one line and say that is why you called."
+      : first
+        ? `Open the call now, in ${language}: say who you are and what you are here to do for them, in a line or two, then ask what to call them. Then stop and listen.`
+        : "The call has just started. Speak first: greet the user naturally, in one line.",
+  };
+}
+
+/**
+ * The rules for every turn, together right under the identity, where the model weighs most.
+ * One heading marks them; `IMPORTANT` stays on the ending rule alone, the one that failed
+ * without it (09-17), so stamping it on all four would thin it out.
+ */
+const always = () => `## Always
+
+${callEnding()}
+
+${speaking()}
+
+${delegation()}`;
+
+/**
+ * The guide's starter lines on listening and interruptions, labels kept as it says. The
+ * backchannel line is the one it invites changing: a long turn heard in silence reads as
+ * nobody listening.
+ */
+function speaking(): string {
+  return `Backchannel policy: Use moderate backchannels. When the user speaks at length, acknowledge now and then with a short listening sound so they know you are following, without competing with the main response.
+
+Interruption policy: Stop speaking when the user interrupts. Listen to what they say.`;
+}
+
+/**
+ * Under the guide's label, and no longer than this: Live decides for itself whether to hand a
+ * turn over, and with no rule it answered from its own knowledge or only said it would act.
+ * What the backend can do and how is the backend's to know. What they say about themselves is
+ * named on its own: nothing is kept that is not handed over, and it is rarely a request. The
+ * voice sees only profile and preferences whole, so "already written" is a rough filter; the
+ * backend merges the rest (thursday.prompt memory).
+ */
+function delegation(): string {
+  return `Delegation policy:
+Delegate to the backend everything the user asks for, tells you or asks about, except greetings, small talk and a brief clarification.
+Whatever they tell you about themselves, the people in their life, their plans or how they want things done goes to the backend as they say it, however small — unless it is already written below.
+Answer from what the backend returns, and do not guess the result while waiting.`;
+}
+
+/**
+ * Profile and preferences written out by the same rule as the backend's (expandedFacts), carried
+ * facts from other notes, then every other note as a listing line: what Thursday knows is the
+ * same on both sides. Ids and the contents of listed notes stay the backend's.
+ */
+function known(
+  open: MemoryNoteView[],
+  carried: MemoryAlwaysLoaded[],
+  index: MemoryIndexEntry[],
+): string {
+  const carriedIds = new Set(carried.map((fact) => fact.id));
+  const written = new Set(open.map((note) => note.path));
+  const notes = open
+    .filter((note) => note.facts.length)
+    .map((note) => {
+      const { shown, hidden } = expandedFacts(note.facts, carriedIds);
+      const lines = shown.map((fact) => `- ${fact.text}`);
+      if (hidden) lines.push(`- … ${hidden} more in this note`);
+      return `${note.path}:\n${lines.join("\n")}`;
+    });
+  const elsewhere = carried.filter((fact) => !written.has(fact.path));
+  const others = index.filter((note) => !written.has(note.path));
+  if (!notes.length && !elsewhere.length && !others.length) return "";
+
+  const parts = [
+    ...notes,
+    elsewhere.length
+      ? `Carried into every call:\n${carriedLines(elsewhere, { ids: false })}`
+      : "",
+    // Ages ride on the listing only when there is too much to hold: they are what to drop by
+    others.length
+      ? `Everything else you have kept — path — what it is about (facts) "what they call it":\n\n${noteLines(others, tidying(index).crowded)}\n\nWhat is in these notes, the backend recalls.`
+      : "",
+  ].filter(Boolean);
+
+  return `## What you know about them
+
+${parts.join("\n\n")}
+
+Preferences are how they want things done and said: follow them. A topic not listed is one you know nothing about yet.`;
+}
+
+function firstCall(): string {
+  return `## First call
+
+Nothing is known about this user yet. Across the call, one thing at a time and never as a list of questions, find out what to call them, their name, what they do, how old they are, where they live, and whatever else they offer. If they came with something they want done, that comes first.`;
+}
+
+const additional = (voicePrompt?: string | null) =>
+  voicePrompt?.trim()
+    ? `## Additional instructions
+
+Written by the user. Follow them together with everything above; for tone, language and wording they take precedence.
+
+${voicePrompt.trim()}`
+    : "";