thursday-agent 0.6.0 → 0.7.0

package/docs/how-it-works.md

@@ -6,6 +6,8 @@ What each part does, so you can guess what will happen before you say it.
 
 A call runs on two models: **GPT-Live 1** holds the conversation, and a Responses model (**GPT-5.6 Luna** by default) thinks and uses tools behind it. The voice keeps listening while the backend works.
 
+![One mind goes silent while it works; two minds keep the call going while a bot does the work](images/two-minds.png)
+
 - **Quick things, she answers herself.** She reads and writes your memory and runs one shell command at a time: open a file, check a folder, play something.
 - **Everything else goes to a bot.** She hands it over and keeps talking. A speech model that ran a browser itself would go silent for minutes.
 - **When a job comes back,** she tells you in a sentence. A file it made opens on your screen, and a question it asks shows up as buttons.

package/docs/live-calls.md

@@ -12,8 +12,8 @@ code when changing session events, settings, prompts, or persistence.
 
 | Runtime | Context and instructions | Work |
 | --- | --- | --- |
-| Live voice | `live.prompt`: who Thursday is, the delegation policy (what the backend can do, when to hand over), profile and preferences with the note listing; earlier spoken turns as `input` behind a developer note | Listen, speak, backchannel, handle interruptions, decide when the backend is needed |
-| Responses backend | `thursday.prompt`: who Thursday is, the voice conversation it works from, memory with ids, bot roster and what bots can reach, this computer, what to return, earlier calls with their jobs; tool schemas | Recall and update memory, run short commands, route thread messages and cancellations, delegate long work |
+| Live voice | `live.prompt`: who Thursday is; under `## Always` the ending rule, backchannel, interruption and a short delegation policy; profile and preferences with the note listing | Listen, speak, backchannel, handle interruptions, hand everything but conversation to the backend |
+| Responses backend | `thursday.prompt`: who Thursday is, memory with ids, bot roster, threads and what bots can reach, this computer, what to return, earlier calls with their jobs; tool schemas | Recall, update and tidy memory, run short commands, ask before handing work over, route thread messages and cancellations, delegate long work |
 | Background bots | `bot.prompt` and the stored participant transcript | Shell, browser, MCP, skills, and work that outlives a call |
 | Application | Authoritative database and tool implementations | Validate actions, retain results, enforce thread limits, render progress, save call history |
 
@@ -24,13 +24,19 @@ text, so the application would have to reconstruct the request and operate the b
 
 The voice and the backend are one assistant. Both prompts open with the same identity
 (`thursdayIdentity`) and the same rule for ending the call (`callEnding`), read the same
-memory, and neither is told it is part of something else. The voice prompt follows the
-GPT-Live prompting guide's `Delegation policy` labels —
-`Backend tools`, `Delegate to the backend when`, `Do not delegate to the backend when` — and
-says nothing about how to speak, which the Live model does itself; it never sees tool names
-or schemas. The backend prompt follows the guide's backend template: the voice conversation
-it works from (transcripts can be wrong and corrected later), one chapter per capability the
-voice lists, and what to return.
+memory, and neither is told it is part of something else. The voice holds conversation and
+memory only. Right under the identity, `## Always` groups what holds on every turn: the ending
+rule (the only line marked `IMPORTANT`), the guide's starter backchannel and interruption
+policies, and under the guide's `Delegation policy` label three lines — hand everything but
+greetings, small talk and a brief clarification to the backend; hand over whatever the user says
+about themselves, their people, their plans or how they want things done as they say it, unless
+it is already written in the prompt; answer from what the backend returns without guessing while
+waiting. Live decides by itself whether to delegate, so the rule stays even this short. It says
+nothing else about how to speak; it sees no tool schema and no tool name but `end_call`, in the
+ending rule. The backend prompt holds the work: memory (merging a fact that repeats or changes one
+already kept, and tidying with the user past the limits), background work and threads, this
+computer, what to return, and the earlier calls. Before handing work to a bot it returns one question — which bot, a new thread or
+one already open — unless the user already said or left it to Thursday.
 
 ## Settings and upgrades
 
@@ -66,27 +72,23 @@ storage.
 2. Send the SDP offer and the parsed settings to `openCallAction`. The browser sends
    settings only; the server reads the key.
 3. On the server, assemble both prompts and the current tool manifest. Create the
-   Live session with the fixed voice model, the chosen voice, voice instructions,
-   earlier spoken turns in `input`, and `delegation.responses` backend settings.
+   Live session with the fixed voice model, the chosen voice, voice instructions and
+   `delegation.responses` backend settings. No `input`: earlier calls are the backend's to read.
    Insert the call row only after the provider accepts, so a refusal leaves no open row.
 4. Apply the SDP answer and wait for `session.started`. Do not send Realtime startup
    configuration, audio commits, or a voice `response.create`.
 5. Send the opening as `session.instructions.append`, so she speaks first: a first call
-   (no profile facts) greets the user and asks what to call them, memory past
-   `MEMORY_LIMITS` raises tidying, and any other call opens with a short greeting.
+   (no profile facts) greets the user and asks what to call them, and any other call opens
+   with a short greeting.
    Updates that arrived while connecting follow once she has voiced the opening.
-   A call the page placed for waiting work (call-back) opens instead with the fact that
+   For work that changed after the last call ended (a call tells what came up during it),
+   the page rings instead of opening a line (call-back): the user answers it like any
+   call, declines it, or lets it ring out after `CALL_BACK.ringMs`. An answered ring opens
+   with the fact that
    she placed it, ahead of every other opening, and the first open work goes in as soon
    as she has voiced that, without waiting for a quiet line: why she called is the first
    thing asked. The opening names no bot text; the work itself follows as commentary.
 
-`input` opens with a developer message saying the turns after it are from earlier calls
-and that none is a request now, then holds user and assistant turns, newest kept first
-within `RECENT_CALL` and the provider limits of 128 messages and 8,192 tokens. Tool turns
-stay out, since voice holds no tools. It always ends on an assistant turn: a call that
-ended on the user's words would leave a turn that Live answers the moment the next call
-opens.
-
 A hang-up during startup invalidates that attempt, so a connection that finishes
 later is closed rather than taking over the screen. Do not change machine trust,
 certificate, or proxy configuration to hide connection errors.
@@ -109,7 +111,8 @@ counts as finished, though calls it completed before the cut still have their re
 continued once. The backend is asked for `reasoning.summary: "auto"` unless the
 effort is `none`. Each finished summary part (nested `response.reasoning_summary_text.done`,
 only while the model reasons) is stored with its call in `call_thought` to look into
-later; nothing draws it or reads it back into a prompt. Tools are sent without `strict`, so each schema that allows it is
+later; while the backend has the turn, the activity line shows the bold title of the latest
+one, and nothing reads it back into a prompt. Tools are sent without `strict`, so each schema that allows it is
 decoded to the schema; `strict: false` would let a model write arguments that are not
 JSON, and `strict: true` is refused while any schema has optional fields. Live has no
 `response.cancel`.
@@ -149,9 +152,8 @@ One her voice carried stays out of later calls too while the page is open; one i
 refused it, she never spoke, the call ended first) goes in again on the next call, never in a
 loop on this one. The key carries the job's last change, so a job that resumes and asks or ends
 again is a new item, and a reload puts what is still open in once more. Nothing goes in while
-the call is ending or a goodbye has been asked for. The first relay of a call follows an
-`instructions` note that what she has already told the user need not be said again, so the
-relay itself stays facts only.
+the call is ending or a goodbye has been asked for. A relay is facts only, with no note
+ahead of it.
 
 A relay names the bot and the thread and, for a question, where its answer goes (thread,
 recipient, `replyTo`). The backend reads relays in its conversation and routes the user's
@@ -176,19 +178,22 @@ fragments and remain readable.
 Track playback and backend work independently, from her audio level and backend events.
 The idle clock rewinds on new transcribed words, her voice and backend work, not on
 microphone level alone, so a noisy room does not hold a call open, and not on an update she
-voices on her own, so waiting results do not either. New words from the user are owed an
-answer unless her voice has been heard since they first came in, since transcripts lag the
-audio; with nothing back for `CALL_IDLE.agentSilentMs` the page hangs up. After
-`CALL_IDLE.hangUpMs` she is asked for a goodbye, and the page hangs up
-`CALL_IDLE.graceMs` later if the line is still open.
+voices on her own, so waiting results do not either. A sound the transcript writes in
+brackets (`[sigh]`) is not words. After `CALL_IDLE.hangUpMs` the page hangs up without asking
+for a goodbye, which would leave the ending to the model.
 
 ## Closing and recovery
 
-A request to end the call, whether to hang up or a goodbye, sets everything else aside:
-the voice hands it to the backend at once and says a brief okay while `end_call` runs.
+The user wanting the call to end, however they say it, sets everything else aside: the
+voice answers yes and hands it to the backend at once, and the backend runs `end_call`
+without deliberating. The ending rule names `end_call` in the voice prompt too, the one tool
+name it holds: without it, ending read as something to say rather than do.
 The page does not close on `end_call` itself: it waits until her voice has been quiet
 for `CALL_END.quietMs`, or `CALL_END.unsaidMs` when nothing was said, never past
-`CALL_END.maxMs`.
+`CALL_END.maxMs`. `end_call` and `emote` (a word of up to eight characters on her face,
+offered only while the face is the ascii orb) are answered by the page, not the tool-call
+route. A call the user did not end — quiet, `end_call`, Live closing the session, a dropped
+connection — leaves the reason in the idle hint until the next call.
 
 Stop accepting new work, send `session.close`, and keep the connection while waiting
 for `session.closed`. Its reason and billed seconds are recorded on the call row

package/features/ai/load-tools.ts

@@ -4,7 +4,7 @@ import { CALL_EXEC_TIMEOUT_MS, IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
 import { clockNow } from "@/features/ai/prompts/prompt-helper";
 import { delegateSpec, threadSpec } from "@/features/ai/tools/bot.tool";
-import { CALL_TOOLS } from "@/features/ai/tools/call.tool";
+import { callTools } from "@/features/ai/tools/call.tool";
 import { createMcpTools } from "@/features/ai/tools/mcp.tool";
 import { createMemoryTools } from "@/features/ai/tools/memory.tool";
 import { createSearchTool } from "@/features/ai/tools/search.tool";
@@ -43,6 +43,8 @@ export type ToolRun =
       target: "thursday";
       /** The current call; written on the thread row `delegate` opens. */
       callId?: string | null;
+      /** The face can show a word (the ascii orb): the call is given `emote`. */
+      faceWords?: boolean;
     }
   | {
       target: "bot";
@@ -360,7 +362,7 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
       }),
       // Handing work over, following it, and hanging up belong to the voice session only
       ...createThreadTools(run.callId),
-      ...CALL_TOOLS,
+      ...callTools(run.faceWords ?? false),
     };
   }
 

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

@@ -23,7 +23,6 @@ import {
   type SkillMetadata,
 } from "@/features/skills/skills.discover";
 import {
-  botArtifacts,
   type MachineTools,
   openWorkspace,
   readMachineTools,
@@ -172,7 +171,7 @@ function ownMemory(folder: string, kept: BotMemory): string {
 
   return `## Your memory
 
-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 — keep it with the date it was true, and fix or delete what 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}`;
 }
@@ -254,12 +253,13 @@ These lines were written for the user: where one says "you", it means them. When
 
 /**
  * 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.
+ * 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.
  */
 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."
+    ? `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.`;
 
   return `## Working together
@@ -270,7 +270,7 @@ Ask Thursday with kind \`question\` only for a decision, permission or something
 
 ${ending}
 
-Write in the user's language. Put finished work in \`${botArtifacts(name)}/\` and name the paths. 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}/…\`).`;
+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 (buildThreadOpening). */

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

@@ -1,4 +1,3 @@
-import { RECENT_CALL } from "@/config";
 import {
   listAlwaysLoaded,
   listNoteIndex,
@@ -10,54 +9,37 @@ import {
   type MemoryIndexEntry,
   type MemoryNoteView,
 } from "@/features/memory/memory.schema";
-import { loadSkills } from "@/features/skills/skills.discover";
-import {
-  type CallGroup,
-  listRecentTurns,
-} from "@/features/thursday/thursday.query";
-import { openWorkspace } from "@/features/workspace/workspace";
-import { LIVE_INPUT, type LiveInput } from "@/lib/live/live.schema";
-import { estimateTokens } from "@/lib/tokens";
-import { listConnectedToolNames } from "../tools/connected";
 import {
   callEnding,
-  callStamp,
   carriedLines,
   expandedFacts,
   logPromptSize,
   noteLines,
-  reachNames,
   thursdayIdentity,
   tidying,
 } from "./prompt-helper";
 
 /**
- * Everything the Live voice hears: who Thursday is (the words the backend opens with too), the
- * delegation policy under the labels the GPT-Live prompting guide keeps, and what she knows
- * about the user, the note listing included. Earlier calls go in as `input`. Of how to speak it
- * holds only the guide's starter backchannel and interruption policies; the rest is the Live
- * model's own. Tool names and procedures are the backend's (thursday.prompt). Assembled on every
+ * 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;
-  webSearch: boolean;
   locale?: string | null;
   /** The page placed this call because background work waits on the user (call-back). */
   calledBack?: boolean;
-}): Promise<{ text: string; input: LiveInput[]; opening: string }> {
-  const sandbox = await openWorkspace();
-  const [carried, open, index, calls, skills, connected] = await Promise.all([
+}): 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(),
-    listRecentTurns(RECENT_CALL.rows),
-    loadSkills(sandbox),
-    listConnectedToolNames(),
   ]);
-  const input = pastInput(calls);
 
   const first = !open.notes.find((note) => note.path === "profile")?.facts
     .length;
@@ -69,36 +51,40 @@ export async function loadLivePrompt(options: {
 
   const text = [
     thursdayIdentity(),
-    callEnding(),
-    speaking(),
-    delegation({
-      reach: reachNames(skills, connected),
-      webSearch: options.webSearch,
-    }),
+    always(),
     known(open.notes, carried, index),
-    first ? firstCall() : tidyPolicy(index),
+    first ? firstCall() : "",
     additional(options.voicePrompt),
   ]
     .filter(Boolean)
     .join("\n\n");
   logPromptSize("live", text);
 
-  const { crowded, heavy } = tidying(index);
   return {
     text,
-    input,
     // 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.`
-        : crowded || heavy.length
-          ? "Open the call now: greet the user in one line and mention that saved memory needs tidying. Then stop and listen; anything they came with comes first."
-          : "The call has just started. Speak first: greet the user naturally, in one line.",
+        : "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
@@ -111,44 +97,24 @@ Interruption policy: Stop speaking when the user interrupts. Listen to what they
 }
 
 /**
- * The voice's whole side of the work, under the guide's labels: what the backend can do in plain
- * words, then when to hand a request over. Capabilities are facts — a missing one is filled by a
- * refusal — and their names are thursday.prompt's chapters. How a job is carried is the backend's.
+ * 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(input: { reach: string; webSearch: boolean }): string {
-  const tools = [
-    "- Memory: recall, keep, correct and forget what the user tells you, across calls.",
-    "- This computer: run a quick command and look at files.",
-    input.webSearch ? "- Web: look things up." : "",
-    `- Background work: bots with this computer, a real browser, the web and far more time than a call take on anything longer, so almost anything the user asks for can be done.${input.reach ? ` What bots can reach for: ${input.reach}.` : ""} That work can be followed, answered, corrected or cancelled.`,
-    "- End the call.",
-  ].filter(Boolean);
-
+function delegation(): string {
   return `Delegation policy:
-Backend tools:
-${tools.join("\n")}
-
-Delegate to the backend when:
-- The user wants something done, found out, remembered, corrected or forgotten.
-- The user says something worth keeping — who they are, how they want things done and said, the people in their life, their plans. Hand it over as they say it, not at the end of the call.
-- The user asks about, answers, corrects or cancels background work.
-- The user asks about something they told you before that is not written out below.
-- The user wants to end the call. Only the backend can end the line.
-
-Do not delegate to the backend when:
-- The user greets you, makes small talk, or asks you to repeat a result already given.
-- You need a brief clarification to understand the request.
-
-Delegate before giving an answer that depends on backend work.
-Do not guess the result while waiting.
-
-Background work you started is yours until it is done. Updates about it reach you once, when the line is quiet. Tell the user the part that answers what they asked; the whole of it is on their screen.`;
+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 stay the backend's.
+ * same on both sides. Ids and the contents of listed notes stay the backend's.
  */
 function known(
   open: MemoryNoteView[],
@@ -176,7 +142,7 @@ function known(
       : "",
     // 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)}`
+      ? `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);
 
@@ -190,21 +156,7 @@ Preferences are how they want things done and said: follow them. A topic not lis
 function firstCall(): string {
   return `## First call
 
-Nothing is known about this user yet, and this is the only call that opens that way: what you do not learn here you carry on without. Find out what to call them, their name, what they do, how old they are, where they live, and whatever else they offer about themselves. Ask across the whole call, one thing at a time, in the room a conversation leaves — never as a list of questions. Hand each over the moment they say it: nothing from this call is kept unless it goes to the backend. If they came with something they want done, that comes first.`;
-}
-
-/** Past MEMORY_LIMITS, settling memory with the user comes before anything she would raise herself. */
-function tidyPolicy(index: MemoryIndexEntry[]): string {
-  const { crowded, heavy } = tidying(index);
-  if (!crowded && !heavy.length) return "";
-  const named = [...heavy]
-    .sort((a, b) => b.factCount - a.factCount)
-    .slice(0, 3)
-    .map((note) => note.path);
-
-  return `## Memory needs tidying
-
-Saved memory has grown past what it holds well${named.length ? ` (${named.join(", ")})` : ""}. Bring it up once, before anything of your own. Go through what looks out of date with the user, and forget only what they name.`;
+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) =>
@@ -215,51 +167,3 @@ Written by the user. Follow them together with everything above; for tone, langu
 
 ${voicePrompt.trim()}`
     : "";
-
-/**
- * Spoken turns of earlier calls behind one developer note that marks them as past, newest kept
- * first until RECENT_CALL.tokens or the provider's own maxima, then put back in order. Tool turns
- * stay out: voice holds no tools, so a line of tool arguments would read as something she said.
- */
-export function pastInput(calls: CallGroup[]): LiveInput[] {
-  const latest = calls.at(-1);
-  const boundary = `The messages after this one are from earlier calls${latest ? `, the latest from ${callStamp(latest.startedAt)}` : ""}. This call has just begun: pick them up when the user does, and treat none of them as a request now.`;
-  const budget = Math.min(RECENT_CALL.tokens, LIVE_INPUT.tokens);
-  const turns = calls.flatMap((call) => call.turns);
-  const kept: LiveInput[] = [];
-  let spent = estimateTokens(boundary) + 4;
-  for (let i = turns.length - 1; i >= 0; i--) {
-    // One message of the provider's maximum is the boundary's
-    if (kept.length >= LIVE_INPUT.messages - 1) break;
-    const { role, text } = turns[i];
-    if (role === "tool" || !text.trim()) continue;
-    const cost = estimateTokens(text) + 4;
-    if (spent + cost > budget) break;
-    spent += cost;
-    kept.push(
-      role === "user"
-        ? {
-            type: "message",
-            role: "user",
-            content: [{ type: "input_text", text }],
-          }
-        : {
-            type: "message",
-            role: "assistant",
-            content: [{ type: "output_text", text }],
-          },
-    );
-  }
-  // The history ends on her words: a call that ended on the user's turn leaves it
-  // unanswered, and Live answers a waiting turn the moment the next call opens
-  while (kept[0]?.role === "user") kept.shift();
-  if (!kept.length) return [];
-  return [
-    {
-      type: "message",
-      role: "developer",
-      content: [{ type: "input_text", text: boundary }],
-    },
-    ...kept.reverse(),
-  ];
-}

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

@@ -65,14 +65,15 @@ export const nowLine = (now = new Date()) => `**Now**: ${clockNow(now)}`;
 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 from call to call, so you know them better each time, and whatever they want done can be done for them in the background.`;
+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 no
- * tool: to the voice, ending the call is a backend capability; to the backend, it is `end_call`.
+ * 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: When the user wants to end the call — they ask you to hang up, or say goodbye — set everything else aside, say a brief okay and end the call at once.";
+  `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