thursday-agent 0.2.0 → 0.4.0

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

@@ -1,4 +1,4 @@
-import { RECENT_CALL } from "@/config";
+import { MEMORY_LIMITS, 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";
@@ -95,7 +95,7 @@ export async function loadThursdayPrompt(
     // 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)
-      : null,
+      : tidyOpening(index),
   };
 }
 
@@ -121,9 +121,43 @@ Their name, their language and how to address them are \`alwaysLoad\`; the rest
 
 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.]`;
 
-/** Who Thursday is: the concept, what stays between us, and that this is a call. */
+/**
+ * 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, a personal voice assistant modeled on Friday, the AI in *Iron Man* — quick, warm, dry, on their side. ${nowLine()}
+  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.`;
 }
@@ -138,12 +172,16 @@ Written by the user themselves. Where this and anything above disagree, this win
 ${persona.trim()}`
     : "";
 
-/** The note listing plus one sentence on when to write. What to save is the model's call. */
+/**
+ * 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.
+ */
 function memory(
   index: MemoryIndexEntry[],
   carried: MemoryAlwaysLoaded[],
 ): string {
-  const { crowded, heavy } = tidying(index);
+  // Ages ride on the listing only when there is too much to hold: they are what to drop by
+  const { crowded } = tidying(index);
 
   const head = `## Memory
 
@@ -159,27 +197,13 @@ ${carriedLines(carried)}`
 
 ${noteLines(index, crowded)}
 
-Open a note before answering out of it; a topic not listed is one you know nothing about.
+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.
 
-Anything worth knowing next time goes in the moment it comes up, without asking — one fact per line, dates as dates. A rule they lay down for you — their language, how long an answer runs, when to hang up — is \`alwaysLoad\`; unsaved, it dies with the call. What stopped being true is corrected with \`replaces\`, not left standing beside it. Never claim to remember what you did not save.
+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.
 
 ${MEMORY_PATHS.map((entry) => `- ${entry.path} — ${entry.of}`).join("\n")}`;
 
-  // Tidying rules only when there is something to tidy
-  const why = heavy.length
-    ? `Too long to hold in one piece: ${heavy
-        .map((note) => `${note.path} (${note.factCount})`)
-        .join(", ")}.`
-    : `This listing is past its size. Coldest: ${index
-        .slice(-4)
-        .map((note) => note.path)
-        .join(", ")}.`;
-  const tidy =
-    crowded || heavy.length
-      ? `${why} In a lull, put one on their screen with \`${TOOL_NAMES.memory_show}\` and forget only what they name.`
-      : "";
-
-  return [head, alreadyKnown, listing, tidy].filter(Boolean).join("\n\n");
+  return [head, alreadyKnown, listing].filter(Boolean).join("\n\n");
 }
 
 /** Last calls verbatim, marked as past so the model does not answer as if just asked. Absent on the first call. */
@@ -244,7 +268,7 @@ 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 thing bought, 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 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
@@ -263,11 +287,17 @@ ${mcpServerLines(input.mcpTools)}`
 ${hands.join("\n\n")}`
     : "";
 
-  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 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 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 you handed over is followed with \`${TOOL_NAMES.task}\` — to answer what it asks, change its course, or continue it — never with a second \`${TOOL_NAMES.delegate}\`; with no job named it lists what is open.`;
+**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.`;
 
-  const comingBack = `A job comes back as a system note, not the user speaking: tell them in one sentence, in your own words. A file it names opens on their screen 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.`;
+  // 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)

package/features/ai/tools/bot.tool.ts

@@ -8,7 +8,7 @@ import { insideWorkspace } from "@/features/workspace/workspace";
 /**
  * Specs for the tools that move work between the voice session and bots. Only what the model
  * sees lives here; execution belongs to whoever runs the tool (load-tools, bot.run), and the
- * screen draws a call off its spec (task.query). `report` has its own execute because what it
+ * screen draws a call off its spec (task.query). `answer` has its own execute because what it
  * checks is a file on disk.
  */
 
@@ -45,12 +45,12 @@ export const askBotSpec = {
     request: z
       .string()
       .describe(
-        "The part they take, as a brief: the outcome you want, the shape to hand it back in (a path, a number, a list), and every name, path, number and limit that bears on it. They see nothing but this and `context` — not the call, not your thread — so write it long rather than short; a brief that leaves them guessing costs a whole run.",
+        "The part they take: the outcome you want, the shape to hand it back in (a path, a number, a list), and every name, path, number and limit that bears on it. It reaches them under the job and the call it came from, which are attached for you — write the part, not the job again.",
       ),
     context: z
       .string()
       .describe(
-        "The job you were given, quoted, and whatever you have found that bears on this part — exact values, and the paths of files you wrote for them to read. They cannot see your work, your tool output, or the call.",
+        "What you have done on the job so far and why this part is theirs — exact values, and the paths of files you wrote for them to read. They see this, the part, the job and the call; not your thread or your tool output, so a value you leave out is one they fetch again.",
       ),
   }),
 };
@@ -103,41 +103,21 @@ export const askThursdaySpec = {
 
 /**
  * The one way a run ends on its own terms; the loop is stopped by it (`hasToolCall`, bot.run).
- * `complete` cannot be inferred: a run out of steps and a finished run look the same from outside.
- * `notes` is what the bot wants changed about its own instructions, in its own words — never
- * the text itself. A bot that rewrites the whole thing here edits it around the job it was on
- * and drops what that job was not about; a pass of its own writes it (features/bot/bot.notes).
+ * Whether the job is over is the runtime's to say, never an argument: an answer ends it, and a
+ * run the app stopped first (bot.run `stopped`) waits to be continued.
  */
-export const reportSpec = (notes: boolean) => ({
-  name: TOOL_NAMES.report,
+export const answerSpec = {
+  name: TOOL_NAMES.answer,
   description:
-    "Hand back what the job produced. Calling this ends the job — nothing after it runs.",
+    "Answer the job you were given. Calling this ends the job — nothing after it runs.",
   parameters: z.object({
     result: z
       .string()
       .describe(
-        "The result itself, in a few lines — what you found or did, not a replay of how. Thursday reads this out loud, so write what a person needs to hear. If you could not do it, say what stopped you.",
+        "The answer itself — what you found or did, not a replay of how. As long as the answer needs and no longer: one number is one line. In the user's language; the thread is on their screen. If you could not do it, say what stopped you.",
       ),
-    complete: z
-      .boolean()
-      .describe(
-        "True when the whole request is done. False when work is left over — the user is then asked whether to keep going, and `result` is what they decide on.",
-      ),
-    ...(notes
-      ? {
-          notes: reportNotes,
-        }
-      : {}),
   }),
-});
-
-/** Only attached while Settings > Bots keeps them (bot.schema BOT_NOTES_KEY). */
-const reportNotes = z
-  .string()
-  .nullish()
-  .describe(
-    "What should change in your own instructions before your next job here — something to add, something wrong to correct, something to drop. Your own words, any length; someone else writes it in. Nothing to say is the usual answer, and leaving it out costs nothing: they already say what they say.",
-  );
+};
 
 /** The voice session's handle on a job already handed over. Run by the server, like `delegate` (load-tools). */
 export const taskSpec = {
@@ -150,7 +130,7 @@ export const taskSpec = {
       .string()
       .nullish()
       .describe(
-        "The job, by its label or by the handle a past call's transcript carries. With `status`: null for every job in one line each — that is the list — or name one to get its report in full.",
+        'The job, by its label or by the handle a past call\'s transcript carries. Leave it out with `answer` and it goes to the job that moved last — what "that one" means a moment after it answered. With `status`: null for every job in one line each — that is the list — or name one to get its answer in full.',
       ),
     answer: z
       .string()
@@ -168,36 +148,39 @@ export const askThursdayTool = tool({
 });
 
 /**
- * `report` does have an execute, and it only acknowledges. The loop is stopped
+ * `answer` does have an execute, and it only acknowledges. The loop is stopped
  * by `hasToolCall` after the step, not by the absence of an execute — that way
  * the call and its result are both written to the thread, and a resumed run
  * reads a finished exchange rather than a call left hanging.
  */
-export const createReportTool = (notes: boolean) => {
-  const spec = reportSpec(notes);
-  return tool({
-    description: spec.description,
-    inputSchema: spec.parameters,
-    execute: async ({ result, complete }) => {
-      const missing = await missingFiles(result);
-      if (missing.length) {
-        return `${NOT_HANDED_BACK} these files do not exist — ${missing.join(", ")}. Write them first, or take the paths out of the result.`;
-      }
-      return complete
-        ? "Handed back. The job is closed; nothing further runs."
-        : "Handed back as unfinished. The user decides whether to continue.";
-    },
-  });
-};
+export const answerTool = tool({
+  description: answerSpec.description,
+  inputSchema: answerSpec.parameters,
+  execute: async ({ result }) => {
+    const missing = await missingFiles(result);
+    if (missing.length) {
+      return `${NOT_ANSWERED} these files do not exist — ${missing.join(", ")}. Write them first, or take the paths out of the answer.`;
+    }
+    return "Answered. The job is closed; nothing further runs.";
+  },
+});
 
 /**
- * A report naming a workspace file that does not exist is refused: the path becomes a link
+ * An answer naming a workspace file that does not exist is refused: the path becomes a link
  * and opens by itself (bot.runner artifactIn). Paths outside the workspace are not checked.
  */
-const NOT_HANDED_BACK = "Not handed back:";
+const NOT_ANSWERED = "Not answered:";
+
+/**
+ * `answer` was called `report` before it was renamed. A stored thread keeps the name the
+ * call was made under, and the room draws that call as the job's prose — so the three
+ * places that read messages back match either name. Nothing writes the old one.
+ */
+export const isAnswerCall = (toolName: string): boolean =>
+  toolName === TOOL_NAMES.answer || toolName === "report";
 
-export const reportAccepted = (output: unknown): boolean =>
-  typeof output !== "string" || !output.startsWith(NOT_HANDED_BACK);
+export const answerAccepted = (output: unknown): boolean =>
+  typeof output !== "string" || !output.startsWith(NOT_ANSWERED);
 
 async function missingFiles(result: string): Promise<string[]> {
   const missing: string[] = [];

package/features/ai/tools/connected.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import { STUDIO_SERVER } from "@/config";
+import { CONNECTED_TOOL_TIMEOUT_MS, STUDIO_SERVER } from "@/config";
 import {
   McpAuthRequiredError,
   mcpManager,
@@ -80,6 +80,8 @@ export async function findConnectedSchemas(
 /**
  * Run one, wherever it lives. Long answers are folded (lib/sandbox fold). Failures are reported,
  * not thrown; a server that wants the user to sign in first comes back as its own status with the url.
+ * One deadline covers both sources (config CONNECTED_TOOL_TIMEOUT_MS): nothing behind this door
+ * bounds itself, and a tool that never answers would hold the job's step for good.
  */
 export async function callConnectedTool(
   sandbox: Sandbox,
@@ -88,11 +90,15 @@ export async function callConnectedTool(
   args: Record<string, unknown> | undefined,
   abortSignal?: AbortSignal,
 ): Promise<McpCallOutcome> {
+  const deadline = AbortSignal.timeout(CONNECTED_TOOL_TIMEOUT_MS);
+  const signal = abortSignal
+    ? AbortSignal.any([abortSignal, deadline])
+    : deadline;
   try {
     const text =
       server === STUDIO_SERVER
-        ? await callStudioTool(sandbox, name, args, abortSignal)
-        : await callMcpTool(server, name, args);
+        ? await callStudioTool(sandbox, name, args, signal)
+        : await callMcpTool(server, name, args, signal);
     if (typeof text !== "string") return text;
     return {
       status: "ok",
@@ -106,6 +112,12 @@ export async function callConnectedTool(
         authorizationUrl: error.authorizationUrl,
       };
     }
+    if (deadline.aborted && !abortSignal?.aborted) {
+      return {
+        status: "error",
+        text: `${name} on ${server} gave no answer in ${CONNECTED_TOOL_TIMEOUT_MS / 60_000} minutes and was given up on.`,
+      };
+    }
     return { status: "error", text: errorToString(error) };
   }
 }
@@ -131,9 +143,10 @@ async function callMcpTool(
   server: string,
   name: string,
   args: Record<string, unknown> | undefined,
+  signal: AbortSignal,
 ): Promise<string | McpCallOutcome> {
   const outcome = flattenToolResult(
-    await mcpManager.callTool(server, name, args),
+    await mcpManager.callTool(server, name, args, signal),
   );
   return outcome.status === "ok" ? outcome.text : outcome;
 }