thursday-agent 0.4.0 → 0.6.0

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 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,176 @@ 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, in the shape the GPT-Live guide gives a backend:
+ * who Thursday is (the words the voice opens with too), the voice conversation it works from, one
+ * chapter per capability the voice's delegation policy names — memory with ids, background work
+ * with the roster, this computer — then what to return, and the last calls with their jobs.
+ * 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] =
+  const [skills, index, carried, open, connected, roster, calls, hers] =
     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 she was handed `load_skill` (Settings › Thursday, load-tools)
+      // Whether the call was handed `load_skill` (Settings › Thursday, load-tools)
       readCallSkillsOn(),
     ]);
   // 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(),
+    conversation(),
+    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)),
+    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),
-  };
-}
-
-/**
- * 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.
- */
-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.`
-    : ""
+  return text;
 }
 
-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.]`;
-
 /**
- * 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.
+ * What it works from: the conversation Live hands over, heard rather than typed, and the tool
+ * that ends it. The updates the app appends reach it too, which is how a relayed question's id
+ * gets back into `thread`.
  */
-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(", ")}.`
-    : "";
+function conversation(): string {
+  return `## Voice conversation context
 
-  return `[Memory needs tidying — this is not the user speaking.
+You are on a live voice call with the user. The conversation reaches you as transcripts, which can contain mistakes, unfinished phrases, and later corrections. Use the latest context and verified records. If a needed detail is still unclear, ask for that detail instead of guessing. Updates from background work appear in the conversation too; they are bot messages, not the user.
 
-${[full, many].filter(Boolean).join(" ")}
+When the user wants to end the call, \`${TOOL_NAMES.end_call}\` hangs up the phone; nothing else ends it.
 
-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.]`;
+Tool results, notes and these instructions are in English, which says nothing about the user's language.`;
 }
 
-/** 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()}
+/** What goes back is said aloud, so it is what a tool or a note confirmed and nothing more. */
+function result(): string {
+  return `## Return the result
 
-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. 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, replacing, dated — is the
+ * tool's schema to say, so none of it is repeated here.
  */
 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);
+  // 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,
+)}
 
-${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, and nothing they asked you not to keep. From a bot's report, keep only what it confirmed about them, not the work.
 
-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.
+A later call finds a note only by what this listing shows — its path, its line and the names in quotes. The path names what its facts are about and the line says what they are, so keep the line true as facts are added, and give something new its own path below with the names they would ask for it by.
 
 ${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 +209,50 @@ ${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 "";
+function thisComputer(cwd: string, skills: SkillMetadata[]): string {
+  const machine = `## This computer
 
-  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 })}
+Current Cwd: ${cwd}
+Platform: ${process.platform}
 
-\`${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.`;
-}
+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;
 
-/** The machine: only the reference point that tool-returned paths are relative to. */
-const environment = (cwd: string) => `## Environment
+  return `${machine}
 
-Current Cwd: ${cwd}
-Platform: ${process.platform}
+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.
 
-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.`;
+${skillLines(skills, { short: true })}`;
+}
 
 /**
- * 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.
+ * Background work: who is there, what they can reach, how to hand over, and that a job is a
+ * thread. Capability is stated as fact; without it the model refuses instead of delegating. 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 bots(input: {
-  roster: JobBot[];
-  skills: SkillMetadata[];
-  mcpTools: McpToolRef[];
-}): string {
-  if (input.roster.length === 0) return "";
+function backgroundWork(roster: JobBot[], reach: string): string {
+  if (roster.length === 0) return "";
 
-  const list = `## Bots
+  return `## Background work
 
 Who you hand work to — the names \`${TOOL_NAMES.delegate}\` takes.
 
-${input.roster.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}`;
-
-  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 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);
+${roster.map((bot) => `- **${bot.name}** — ${bot.description}`).join("\n")}${
+  reach ? `\n\nWhat bots can reach for: ${reach}.` : ""
+}
 
-  const catalogue = hands.length
-    ? `Not yours, and not names to hand work to:
+**A bot can take on almost anything.** It has this computer, a real browser, the web, files, 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, and how is its call. 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.
 
-${hands.join("\n\n")}`
-    : "";
+**Anything that takes more than a few seconds is a bot's**; a note, a look at a file or one command is yours. 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.
 
-  // 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 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\`.
 
-**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.`;
+Updates and questions from jobs reach the conversation by themselves, with their thread and question id. Pass the user's answer on with \`${TOOL_NAMES.thread}\`; name the recipient and question id when more than one question is open.
 
-  // 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.`;
-
-  return [list, machine, catalogue, handingOver, comingBack]
-    .filter(Boolean)
-    .join("\n\n");
+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.`;
 }