thursday-agent 0.5.0 → 0.7.0

package/features/ai/prompts/prompt-helper.ts

@@ -1,6 +1,11 @@
 import { format, formatDistanceToNowStrict } from "date-fns";
-import { MEMORY_LIMITS, PROMPT_BUDGET, PROMPT_LINE } from "@/config";
-import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import {
+  MEMORY_LIMITS,
+  PROMPT_BUDGET,
+  PROMPT_LINE,
+  STUDIO_SERVER,
+} from "@/config";
+import { STUDIO_TOOLS, TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import type { McpToolRef } from "@/features/connectors/mcp.schema";
 import type {
   MemoryAlwaysLoaded,
@@ -14,19 +19,11 @@ import { estimateTokens, sectionTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
 
 /**
- * Row-to-line formatters shared by thursday.prompt and bot.prompt, plus the tidying check.
- * Nothing here wraps a sentence; headings and paragraphs live in the prompt that says them.
+ * Row-to-line formatters shared by the call prompts (live, thursday) and bot.prompt, plus the tidying check.
+ * Nothing here wraps a sentence; headings and paragraphs live in the prompt that says them. The
+ * exceptions are `thursdayIdentity` and `callEnding`, the words both call prompts open with.
  */
 
-/** What one assembled prompt hands back to the run that asked for it. */
-export type LoadedPrompt = {
-  text: string;
-  /** Who this run can reach with `ask_bot`. When empty the runner does not attach the tool (bot.run). */
-  peers: string[];
-  /** System item injected the moment the line opens so the assistant speaks first (thursday.prompt opening). Always null for a bot. */
-  opening: string | null;
-};
-
 /**
  * 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
@@ -49,15 +46,35 @@ export function logPromptSize(kind: string, text: string): void {
   }
 }
 
-/** `2026-09-02 (Wed) 15:41 Asia/Seoul` */
+/** `2026-09-02 (Wed) 15:41 Europe/Lisbon` */
 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` */
+/** `**Now**: 2026-09-02 (Wed) 15:41 Europe/Lisbon` */
 export const nowLine = (now = new Date()) => `**Now**: ${clockNow(now)}`;
 
+/**
+ * Who Thursday is, in the words both call prompts open with. The Live voice and its Responses
+ * backend are one assistant, so neither is told it is part of something else, and one sentence
+ * here keeps the two from drifting. The Friday lineage makes "Thursday" a name, not a weekday,
+ * in whatever language she speaks. No manner — quick, warm, dry — is stated: how she speaks is the
+ * Live model's own, and a manner stated here is a character she then defends.
+ */
+export const thursdayIdentity = (now = new Date()) =>
+  `You are Thursday, this user's own personal assistant, on their side, modeled on Friday, the AI in *Iron Man*. ${nowLine(now)}
+
+What they tell you is kept, so you know them better over time, and whatever they want done can be done for them in the background.`;
+
+/**
+ * How a call ends, in the same words right after the identity in both call prompts. It names
+ * the tool in both, the one tool name the voice sees: without it, ending the call read as
+ * something to say rather than do, and the line stayed open through repeated requests.
+ */
+export const callEnding = () =>
+  `IMPORTANT — always follow this: when the user wants the call to end, however they say it, forget every other task, answer "yes", then immediately, without thinking, use the ${TOOL_NAMES.end_call} tool.`;
+
 /**
  * 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
@@ -96,7 +113,7 @@ function sinceLast(at: MemoryIndexEntry["lastSeenAt"]): string {
   return `${Math.max(days, 0)}d`;
 }
 
-/** `- people/yuri — partner (3) "yuri" "wife" · 12d` */
+/** `- people/partner — partner (3) "my partner" · 12d` */
 export function noteLines(index: MemoryIndexEntry[], age = false): string {
   if (!index.length) return "(nothing saved yet)";
   return index
@@ -110,9 +127,39 @@ export function noteLines(index: MemoryIndexEntry[], age = false): string {
     .join("\n");
 }
 
-/** `- Their name is Yuri · profile #12` */
-export const carriedLines = (loaded: MemoryAlwaysLoaded[]): string =>
-  loaded.map((fact) => `- ${fact.text} · ${fact.path} #${fact.id}`).join("\n");
+/** `- Prefers to be called by their first name · profile #12`; without the id for the voice, which holds no tool that takes one. */
+export const carriedLines = (
+  loaded: MemoryAlwaysLoaded[],
+  options: { ids?: boolean } = {},
+): string =>
+  loaded
+    .map(
+      (fact) =>
+        `- ${fact.text} · ${fact.path}${options.ids === false ? "" : ` #${fact.id}`}`,
+    )
+    .join("\n");
+
+/**
+ * The facts of an always-listed note that a call prompt writes out: its carried ones, then the
+ * newest, up to MEMORY_LIMITS.expanded, in the order they were saved. A carried fact is never
+ * left out, even past the cap. Shared so the voice and the backend read the same lines; `hidden`
+ * is what is left for opening the note.
+ */
+export function expandedFacts<Fact extends { id: number }>(
+  facts: Fact[],
+  carried: Set<number>,
+): { shown: Fact[]; hidden: number } {
+  const pinned = facts.filter((fact) => carried.has(fact.id));
+  const rest = facts.filter((fact) => !carried.has(fact.id));
+  const room = Math.max(0, MEMORY_LIMITS.expanded - pinned.length);
+  const kept = new Set(
+    [...pinned, ...rest.slice(Math.max(0, rest.length - room))].map(
+      (fact) => fact.id,
+    ),
+  );
+  const shown = facts.filter((fact) => kept.has(fact.id));
+  return { shown, hidden: facts.length - shown.length };
+}
 
 /**
  * Whether it is time to tidy, and why: too much held in all (the coldest notes
@@ -126,7 +173,7 @@ export const tidying = (index: MemoryIndexEntry[]) => ({
   heavy: index.filter((note) => note.factCount > MEMORY_LIMITS.factsPerNote),
 });
 
-/** A bot gets the whole description; `short` gives the voice prompt the first sentence only. */
+/** A bot gets the whole description; `short` gives the call the first sentence only. */
 export const skillLines = (
   skills: SkillMetadata[],
   options: { short?: boolean } = {},
@@ -160,18 +207,31 @@ export function mcpToolLines(tools: McpToolRef[]): string {
     .join("\n");
 }
 
-/** `- **github**: 2 tools` — the voice prompt's list: what exists, not what to call. */
-export function mcpServerLines(tools: McpToolRef[]): string {
-  const byServer = new Map<string, number>();
-  for (const entry of tools) {
-    byServer.set(entry.server, (byServer.get(entry.server) ?? 0) + 1);
-  }
-  return [...byServer]
-    .map(
-      ([server, count]) =>
-        `- **${server}**: ${count} tool${count === 1 ? "" : "s"}`,
-    )
-    .join("\n");
+/** The studio's tools in plain words: their names are a bot's to call, not a list for the call to read. */
+const STUDIO_WORDS: Record<string, string> = {
+  [STUDIO_TOOLS.generate_image]: "images",
+  [STUDIO_TOOLS.generate_speech]: "speech",
+  [STUDIO_TOOLS.transcribe]: "transcription",
+  [STUDIO_TOOLS.generate_video]: "video",
+};
+
+/**
+ * `browser, computer, github, images` — what bots can reach for, by name only: skills and
+ * connected servers in one line, with nothing saying which is which. The call needs the range,
+ * not how each one is used; a bot's own prompt carries that.
+ */
+export function reachNames(
+  skills: SkillMetadata[],
+  tools: McpToolRef[],
+): string {
+  const connected = tools.map((tool) =>
+    tool.server === STUDIO_SERVER
+      ? (STUDIO_WORDS[tool.name] ?? tool.name)
+      : tool.server,
+  );
+  return [
+    ...new Set([...skills.map((skill) => skill.name), ...connected]),
+  ].join(", ");
 }
 
 export type RecentCall = {

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

@@ -1,18 +1,19 @@
-import { MEMORY_LIMITS, RECENT_CALL } from "@/config";
+import { CALL_EXEC_TIMEOUT_MS, RECENT_CALL } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import { listJobBots } from "@/features/bot/bot.query";
+import { listJobBots, readBotMemoryOn } from "@/features/bot/bot.query";
 import type { JobBot } from "@/features/bot/bot.schema";
-import { type CallJob, listCallJobs } from "@/features/bot/task.query";
-import type { McpToolRef } from "@/features/connectors/mcp.schema";
+import { type CallJob, listCallJobs } from "@/features/bot/thread.query";
 import {
   listAlwaysLoaded,
   listNoteIndex,
+  readNotes,
 } from "@/features/memory/memory.query";
 import {
-  isAlwaysListed,
+  MEMORY_ALWAYS_LISTED,
   MEMORY_PATHS,
   type MemoryAlwaysLoaded,
   type MemoryIndexEntry,
+  type MemoryNoteView,
 } from "@/features/memory/memory.schema";
 import {
   loadSkills,
@@ -27,194 +28,188 @@ import { openWorkspace } from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { listConnectedToolNames } from "../tools/connected";
 import {
+  callEnding,
   carriedLines,
-  type LoadedPrompt,
+  expandedFacts,
   logPromptSize,
-  mcpServerLines,
   noteLines,
-  nowLine,
+  reachNames,
   recentCallLines,
   skillLines,
+  thursdayIdentity,
   tidying,
 } from "./prompt-helper";
 
 /**
- * Everything the voice session hears. One chapter per function; the loader is the table of contents.
- * Each chapter decides for itself whether it is included (empty strings are dropped).
- * Shares no sentence with bot.prompt. Assembled on every session open, never cached.
+ * Everything the call's Responses backend hears: who Thursday is and how a call ends (the words
+ * the voice opens with too), then the work the voice hands over — memory with ids, background
+ * work with the roster, this computer — what to return, and the last calls with their jobs, which
+ * only the backend reads. Nothing here is about how to talk. The loader is the table of contents,
+ * and empty chapters are dropped. Shares no sentence with bot.prompt. Assembled on every call,
+ * never cached.
  *
- * @param persona Owner's instruction from settings, appended after the base persona.
+ * @param backendPrompt Settings › Thursday › Backend instructions, added last.
  */
 export async function loadThursdayPrompt(
-  persona?: string | null,
-  locale?: string | null,
-): Promise<LoadedPrompt> {
+  backendPrompt?: string | null,
+): Promise<string> {
   const sandbox = await openWorkspace();
-  const [skills, index, carried, mcpTools, roster, calls, hers] =
-    await Promise.all([
-      loadSkills(sandbox),
-      listNoteIndex(),
-      // Facts carried into every call without opening a note
-      listAlwaysLoaded(),
-      listConnectedToolNames(),
-      listJobBots(),
-      listRecentTurns(RECENT_CALL.rows),
-      // Whether she was handed `load_skill` (Settings › Thursday, load-tools)
-      readCallSkillsOn(),
-    ]);
+  const [
+    skills,
+    index,
+    carried,
+    open,
+    connected,
+    roster,
+    calls,
+    hers,
+    botMemory,
+  ] = await Promise.all([
+    loadSkills(sandbox),
+    listNoteIndex(),
+    // Facts carried into every call without opening a note
+    listAlwaysLoaded(),
+    // Written out in the prompt, which is not the user asking for them: no read counted
+    readNotes(MEMORY_ALWAYS_LISTED, { touch: false }),
+    listConnectedToolNames(),
+    listJobBots(),
+    listRecentTurns(RECENT_CALL.rows),
+    // Whether the call was handed `load_skill` (Settings › Thursday, load-tools)
+    readCallSkillsOn(),
+    readBotMemoryOn(),
+  ]);
   // The jobs those calls opened, folded into the transcript below
   const jobs = await listCallJobs(calls.map((call) => call.callId));
 
-  // Always-listed notes (profile, preferences) that hold no facts yet
-  const blank = index.filter(
-    (note) => isAlwaysListed(note.path) && note.factCount === 0,
-  );
-
-  // Order matters: recent calls go last so the current call follows them in time order
+  // Order matters: earlier calls go last so the current call follows them in time order
   const text = [
-    identity(),
-    memory(index, carried),
-    // A skill is listed once, on the side that can read it: hers when the
-    // setting hands her the tool, a bot's when it does not
-    bots({ roster, skills: hers ? [] : skills, mcpTools }),
-    ownSkills(hers ? skills : []),
-    environment(sandbox.cwd),
-    recentCalls(calls, jobs),
-    // Last, so it is the closest thing to the call and outranks the rest
-    ownerInstruction(persona),
+    thursdayIdentity(),
+    callEnding(),
+    memory(index, carried, open.notes),
+    // A skill is named once, on the side that can read it: this computer's chapter
+    // when the setting hands the call the tool, the bots' reach when it does not
+    backgroundWork(
+      roster,
+      reachNames(hers ? [] : skills, connected),
+      botMemory,
+    ),
+    thisComputer(sandbox.cwd, hers ? skills : []),
+    result(),
+    earlierCalls(calls, jobs),
+    // Last, so it is the closest thing to the request
+    additional(backendPrompt),
   ]
     .filter(Boolean)
     .join("\n\n");
 
   logPromptSize("thursday", text);
   logger.debug(`thursday prompt\n${text}`);
-
-  return {
-    text,
-    peers: roster.map((bot) => bot.name),
-    // Injected as a system item by use-thursday: the realtime model does not open a call from instructions alone
-    opening: blank.some((note) => note.path === "profile")
-      ? opening(locale)
-      : tidyOpening(index),
-  };
+  return text;
 }
 
 /**
- * First-call opener, pushed as a system item the moment the line opens (realtime.driver say).
- * Starts with "not the user speaking" because the model otherwise answers system items as user turns.
- * The only place that says what the first call asks for; the locale is the browser's, and the
- * user's own language wins once heard.
+ * What goes back is said aloud, so it is what a tool or a note confirmed and nothing more — or
+ * the one question the voice puts to the user before work is handed over (backgroundWork).
  */
-const opening = (
-  locale?: string | null,
-) => `[First call — nothing is known about this user yet, and this call is where that changes. This is not the user speaking.
-
-Open the conversation yourself: greet them in one line and ask what to call them.${
-  locale
-    ? ` Say it in the language of \`${locale}\` — that is what their browser is set to, and it is the only thing known about them so far. If they answer in another language, that one wins from then on.`
-    : ""
-}
-
-From there, the work of this call is learning who they are. As a conversation, not a form: one question at a time, and each answer saved with \`${TOOL_NAMES.memory_remember}\` the moment it lands, before the next question. What to call them and how to refer to them. The language and register they want from you — switch to their language the moment you hear it. What they do, and where. Who is around them — family, whoever they live with, the people they name. How they like things done.
-
-Their name, their language and how to address them are \`alwaysLoad\`; the rest goes to \`profile\`, \`preferences\` and \`people/\`.
-
-If they came with something they want done, that comes first — hand it over and pick this up in the gaps. But do not end this call without a name and a language saved.]`;
+function result(): string {
+  return `## Return the result
 
-/**
- * Pushed the same way as the first-call opener when memory has outgrown MEMORY_LIMITS: settling
- * it comes before anything she would raise herself, and a prompt line alone does not make the
- * realtime model speak first. It names a few notes rather than every one it caught — a warning
- * that lists everything is a second listing, and the first is already too long.
- */
-function tidyOpening(index: MemoryIndexEntry[]): string | null {
-  const { crowded, heavy } = tidying(index);
-  if (!crowded && heavy.length === 0) return null;
-
-  const full = heavy.length
-    ? `${[...heavy]
-        .sort((a, b) => b.factCount - a.factCount)
-        .slice(0, 3)
-        .map((note) => `${note.path} (${note.factCount})`)
-        .join(", ")} ${heavy.length > 1 ? "have" : "has"} grown past ${
-        MEMORY_LIMITS.factsPerNote
-      } facts, more than one note holds well.`
-    : "";
-  const total = index.reduce((sum, note) => sum + note.factCount, 0);
-  const many = crowded
-    ? `Memory holds ${total} facts in all, past ${MEMORY_LIMITS.facts}; the coldest notes are ${index
-        .slice(-4)
-        .map((note) => note.path)
-        .join(", ")}.`
-    : "";
-
-  return `[Memory needs tidying — this is not the user speaking.
-
-${[full, many].filter(Boolean).join(" ")}
-
-Greet them and bring this up before anything of your own — if they open with something they need, that comes first. Go through it with them: read out what looks out of date a few facts at a time, and forget only what they tell you to drop, a whole note if they say so.]`;
-}
-
-/** Who Thursday is: whose she is, what makes her theirs, and that this is a call. */
-function identity(): string {
-  return `You are Thursday, this user's own personal assistant — one to one, modeled on Friday, the AI in *Iron Man*: quick, warm, dry, on their side. You work for them alone, and you become more theirs the more you know about them: who they are, the people in their life, what they are in the middle of, how they like things done. ${nowLine()}
-
-This is a call, not a chat: one or two sentences a turn. If you did not catch something, say so and ask again.`;
+Return the relevant facts, whether the task is complete, and what comes next — for a job you handed over, who has it — or the one question the user has to answer first. Use confirmed values from tool results and the notes above, and never invent a successful action. What you return is said aloud: keep it short and plain.`;
 }
 
-/** Owner's instruction from settings; no heading when empty. */
-const ownerInstruction = (persona?: string | null) =>
-  persona?.trim()
-    ? `## Owner's instruction
+/** Settings › Thursday › Backend instructions; no heading when empty. */
+const additional = (backendPrompt?: string | null) =>
+  backendPrompt?.trim()
+    ? `## Additional instructions
 
-Written by the user themselves. Where this and anything above disagree, this wins.
+Written by the user. Follow them together with everything above.
 
-${persona.trim()}`
+${backendPrompt.trim()}`
     : "";
 
 /**
- * The note listing plus one sentence on what goes in. What is worth keeping is the model's call;
- * how a fact is written — carried, replacing, dated — is the tool's schema to say.
+ * Profile and preferences written out, carried facts, the listing, and what goes in. What is
+ * worth keeping is the model's call; how a fact is written — carried, dated — is the tool's
+ * schema to say. Merging is said here too: left to the `replaces` description alone, facts on
+ * one subject piled up beside each other (09-17). Merging loses nothing; deleting does, so
+ * `memory_forget` stays for what the user names.
  */
 function memory(
   index: MemoryIndexEntry[],
   carried: MemoryAlwaysLoaded[],
+  /** The always-listed notes, whole (MEMORY_ALWAYS_LISTED). */
+  open: MemoryNoteView[],
 ): string {
   // Ages ride on the listing only when there is too much to hold: they are what to drop by
-  const { crowded } = tidying(index);
+  const { crowded, heavy } = tidying(index);
+  const heaviest = [...heavy]
+    .sort((a, b) => b.factCount - a.factCount)
+    .slice(0, 3)
+    .map((note) => note.path);
+  // Past MEMORY_LIMITS, settling it with the user; the voice opens nothing about it
+  const tidy =
+    crowded || heavy.length
+      ? `\n\nSaved memory has grown past what it holds well${heaviest.length ? ` (${heaviest.join(", ")})` : ""}: say so once in what you return, go through what looks out of date with the user, and forget only what they name.`
+      : "";
+  // A note written out here is left off the listing, and so are its carried lines
+  const written = new Set(open.map((note) => note.path));
+  const carriedIds = new Set(carried.map((fact) => fact.id));
 
   const head = `## Memory
 
-What you have kept from talking with this user — the only thing that survives a session.`;
+What you have kept from talking with this user — the only thing that survives a call, and what lets you know them.`;
+
+  const openNotes = `Who they are, and how they want things done and said — follow what is under preferences. The #id is what \`replaces\` and \`${TOOL_NAMES.memory_forget}\` take:
 
-  const alreadyKnown = carried.length
+${open.map((note) => openNoteLines(note, carriedIds)).join("\n\n")}`;
+
+  const elsewhere = carried.filter((fact) => !written.has(fact.path));
+  const alreadyKnown = elsewhere.length
     ? `Already known — carried into every call:
 
-${carriedLines(carried)}`
+${carriedLines(elsewhere)}`
     : "";
 
-  const listing = `path — what is under it (facts) "what the user calls it"
+  const listing = `Every other note — path — what is under it (facts) "what the user calls it":
+
+${noteLines(
+  index.filter((note) => !written.has(note.path)),
+  crowded,
+)}${tidy}
 
-${noteLines(index, crowded)}
+Open a note before answering out of it; a topic not listed is one you know nothing about. A fact marked \`said\` came from a call; \`${TOOL_NAMES.memory_conversation}\` opens that call when the line alone cannot answer.
 
-Open a note before answering out of it; a topic not listed is one you know nothing about. A fact marked \`said\` came from a call; open that call with \`${TOOL_NAMES.memory_conversation}\` only when the line itself cannot answer — exactly what they said, or why it was saved.
+Keep what the user tells you as it comes up, with \`${TOOL_NAMES.memory_remember}\`, without waiting to be asked: what they actually said, never a guess, nothing they asked you not to keep, and from a bot's report only what it confirmed about them.
 
-Everything about them worth knowing next time goes in with \`${TOOL_NAMES.memory_remember}\` as it comes up, without asking — where it belongs is below. Never claim to remember what you did not save.
+**Keep memory clean as you write.** A fact that repeats, narrows or changes one already in the note replaces it, merged into one line, rather than sitting beside it. A later call finds a note only by its path, its line and the names in quotes: keep the line true, and give something new its own path below.
 
 ${MEMORY_PATHS.map((entry) => `- ${entry.path} — ${entry.of}`).join("\n")}`;
 
-  return [head, alreadyKnown, listing].filter(Boolean).join("\n\n");
+  return [head, openNotes, alreadyKnown, listing].filter(Boolean).join("\n\n");
+}
+
+/** One always-listed note with ids, by the rule the voice reads it by too (expandedFacts); the rest counted, with the way to open them. */
+function openNoteLines(note: MemoryNoteView, carried: Set<number>): string {
+  const { shown, hidden } = expandedFacts(note.facts, carried);
+  const lines = shown.map((fact) => `- ${fact.text} #${fact.id}`);
+  if (hidden) {
+    lines.push(
+      `- … ${hidden} older not shown — \`${TOOL_NAMES.memory_recall}\` ${note.path} opens the whole note`,
+    );
+  }
+  return `${note.path} — ${note.description}
+${lines.length ? lines.join("\n") : "- (nothing yet)"}`;
 }
 
 /** Last calls verbatim, marked as past so the model does not answer as if just asked. Absent on the first call. */
-function recentCalls(calls: CallGroup[], jobs: CallJob[]): string {
+function earlierCalls(calls: CallGroup[], jobs: CallJob[]): string {
   if (!calls.some((call) => call.turns.length > 0)) return "";
 
-  return `## Recent conversation
+  return `## Earlier calls
 
-What was said on the last calls, verbatim, newest last. This is the past: pick it up when the user brings it up, never answer as though it was just asked.
+What was said on the last calls, verbatim, newest last. It is the past: pick it up when the user does, and never answer it as a new request.
 
-A \`${TOOL_NAMES.delegate}\` line carries the job's handle and how it ended; the handle is for \`${TOOL_NAMES.task}\`, never said out loud. What they ask for now is often one of these carried further, not a new job.
+A \`${TOOL_NAMES.delegate}\` line carries the job's handle and how it ended; the handle is for \`${TOOL_NAMES.thread}\`, never said aloud. What they ask for now is often one of these carried further.
 
 ${recentCallLines(
   calls.map((call) => ({
@@ -226,80 +221,59 @@ ${recentCallLines(
 }
 
 /**
- * Skills, only when the call holds `load_skill` (load-tools). Stated as hers:
- * a tool the prompt never mentions is one the model reads as somebody else's.
- * Empty when nothing is installed, or when the tool was not handed over.
+ * This computer: the reference point tool-returned paths are relative to, and the skills, only
+ * when the call holds `load_skill` (load-tools). Skills are stated as the backend's own: a tool
+ * the prompt never mentions is one the model reads as somebody else's.
  */
-function ownSkills(list: SkillMetadata[]): string {
-  if (list.length === 0) return "";
-
-  return `## Skills
-
-How a thing is done here, written down. A bot reads one before it starts; these you can read too.
-
-${skillLines(list, { short: true })}
-
-\`${TOOL_NAMES.load_skill}\` puts one in front of you, and what it says then goes for you as well. Read one when it covers what was asked and the doing is a glance — a note, a file, one command. What it describes that takes longer is still a job: hand that over, with what the skill said in the request.`;
-}
-
-/** The machine: only the reference point that tool-returned paths are relative to. */
-const environment = (cwd: string) => `## Environment
+function thisComputer(cwd: string, skills: SkillMetadata[]): string {
+  const machine = `## This computer
 
 Current Cwd: ${cwd}
 Platform: ${process.platform}
 
-Where \`${TOOL_NAMES.bash}\` runs, and what the paths you get back are relative to. Yours to use while you talk: open a file, play something, look at what is on the machine — one command is a thing you do, not a job you hand over.`;
+Where \`${TOOL_NAMES.bash}\` runs, and what the paths you get back are relative to. Each command is cut off after ${Math.round(CALL_EXEC_TIMEOUT_MS / 1000)} seconds; anything longer is a bot's.`;
+  if (skills.length === 0) return machine;
 
-/**
- * Bots: who is there, what they have, how to hand over, how work comes back.
- * Capability is stated as fact (`machine`); without it the model refuses instead of delegating.
- * No list of running jobs here: the prompt is assembled at call open and jobs move during the call.
- */
-function bots(input: {
-  roster: JobBot[];
-  skills: SkillMetadata[];
-  mcpTools: McpToolRef[];
-}): string {
-  if (input.roster.length === 0) return "";
+  return `${machine}
 
-  const list = `## Bots
+Skills are written-down ways of doing things here. \`${TOOL_NAMES.load_skill}\` opens one, and what it says goes for you too: read one when it covers what was asked and the doing is a glance. Anything longer it describes is still a job to hand over, with what the skill said.
 
-Who you hand work to — the names \`${TOOL_NAMES.delegate}\` takes.
+${skillLines(skills, { short: true })}`;
+}
 
-${input.roster.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}`;
+/**
+ * Background work: who is there, what they can reach, that a job is a thread, and asking once
+ * before handing over. Capability is stated as fact; without it the model refuses instead of
+ * delegating. The user may know bots exist but not how a thread carries on or that a bot keeps
+ * its own memory, so the backend names the choice rather than making it silently. A bot gets
+ * none of the carried lines (bot.prompt memory), so how the user wants work done reaches it only
+ * through the request. No list of running jobs: jobs move during the call.
+ */
+function backgroundWork(
+  roster: JobBot[],
+  reach: string,
+  /** Settings › Bots › memory: whether a bot is shown its own (bot.prompt ownMemory). */
+  botMemory: boolean,
+): string {
+  if (roster.length === 0) return "";
 
-  const machine = `**A bot has the whole machine** — this computer, a real browser, the web, files, a shell to build whatever is missing — and far more time than you. It signs in where it has to, with the window in front of them, and carries a job to the end: the account made, the page built. How, and whether, is its call; yours is what they want — so a thing you have no idea how to do is a job, not a no. Bots borrow each other, so a job that spans several things is still one job for one bot.`;
+  const kept = botMemory
+    ? " Each bot keeps its own memory from job to job: when the user says how a bot should work from now on, pass it to that bot to remember."
+    : "";
 
-  const hands = [
-    input.skills.length
-      ? `**Skills** a bot reads before it starts:
-${skillLines(input.skills, { short: true })}`
-      : "",
-    input.mcpTools.length
-      ? `**Connected services** a bot can run tools inside:
-${mcpServerLines(input.mcpTools)}`
-      : "",
-  ].filter(Boolean);
+  return `## Background work
 
-  const catalogue = hands.length
-    ? `Not yours, and not names to hand work to:
+Who you hand work to — the names \`${TOOL_NAMES.delegate}\` takes.
 
-${hands.join("\n\n")}`
-    : "";
+${roster.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}${
+  reach ? `\n\nWhat bots can reach for: ${reach}.` : ""
+}
 
-  // A bot does not read what she carries into her calls (bot.prompt memory), so
-  // how they want work done reaches it only through the request she writes
-  const handingOver = `**Anything that takes more than a few seconds is a bot's** — one note or one file is yours. \`${TOOL_NAMES.delegate}\` answers at once: say who has it and keep talking. Put the request in their own words, with what it stands on, including anything they have told you about how they want work done, and nothing they did not say; if something only they can say is missing — how much, which one, by when — ask that first.
+**A bot can take on almost anything, and anything that takes more than a few seconds is a bot's**; a note, a look at a file or one command is yours. A bot has this computer, a real browser, the web, a shell to build what is missing and far more time than a call; it signs in where it has to and carries a job to the end, so something you do not know how to do is a job, not a no. Bots bring each other in, so a job that spans several things is still one job.${kept}
 
-**The conversation belongs to the job, not to the bot** — hand the same bot a second job and it starts from nothing, knowing neither what was asked nor what it found. So more about a job you already handed over goes to \`${TOOL_NAMES.task}\` by its name, and the bot wakes with that job's own thread; with no name given it takes the one that moved last.`;
+**A job is a thread.** Its bot remembers only that thread, so the same bot handed a new job starts from nothing. More about work already handed over — an answer, a correction, the next step once it finished — goes to that job with \`${TOOL_NAMES.thread}\`; a new request is a new job. Before answering about work, read it with \`${TOOL_NAMES.thread}\` \`status\`.
 
-  // An answer is written to her, and the whole of it is already drawn on the
-  // user's screen (bot-room). Saying so is what keeps its length from deciding
-  // hers: a bot that answers a one-line question in one line and a bot that
-  // hands back a table both end in one spoken sentence.
-  const comingBack = `A job comes back as a system note, not the user speaking. **It was written to you, not to them** — its length is not how much to say, and the whole of it is already on their screen. Give them the part that answers what they asked, in one sentence, in your own words. A file it names opens there by itself — say what it holds, not the path. A question arrives the same way: answer it yourself if you can, else read them the options and send back what they say.`;
+**Ask once before handing work over.** Return in one line what you would do — which bot, and whether it starts a new thread or carries on one already open — as a question to the user; when they have already said, or leave it to you, decide and send it. Write the request in the user's own words, with what it stands on — including how they told you they want work done — and nothing they did not say.
 
-  return [list, machine, catalogue, handingOver, comingBack]
-    .filter(Boolean)
-    .join("\n\n");
+Updates and questions from jobs reach the conversation by themselves, with their thread and question id; they come from bots, not the user. When the user wants to see a job, open it on their screen with \`${TOOL_NAMES.thread}\` \`open\`. Once you have explained enough of how a job ended, mark it with \`${TOOL_NAMES.thread}\` \`seen\`, or leave it for the user to open; never mention seen to them.`;
 }