thursday-agent 0.2.0 → 0.4.0

package/features/thursday/use-thursday.ts

@@ -5,10 +5,9 @@ import { useAppEvent } from "@/app/api/events/app-event.client";
 import { queryKey } from "@/app/api/query-key";
 import { toast } from "@/components/ui/toast";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import { markReportedAction } from "@/features/bot/bot.action";
 import {
   type Bot,
-  isBudgetAsk,
+  isAppStop,
   TASK_CONTINUE,
   type Task,
 } from "@/features/bot/bot.schema";
@@ -45,7 +44,7 @@ import type {
   LiveStatus,
 } from "./thursday.schema";
 import { thursdaySettings, useThursdayStore } from "./thursday.store";
-import { toolLine } from "./tool-line";
+import { toolBot, toolLine } from "./tool-line";
 
 /**
  * One live call, plus the task inbox the app watches even with no call open.
@@ -103,6 +102,14 @@ const IDLE_GRACE_MS = 15_000;
 /** The countdown shows on screen inside this window. */
 const IDLE_WARN_MS = 15_000;
 
+/**
+ * The user finished a turn and nothing came back — no words, no tool — for this
+ * long. The line is up and the model is not on it, so there is no goodbye to
+ * ask for: the page hangs up. Only armed while an answer is owed, so a quiet
+ * line still ends the slow way (IDLE_HANG_UP_MS).
+ */
+const AGENT_SILENT_MS = 30_000;
+
 const IDLE_LINE =
   "The user has said nothing for a minute. Say a one-line goodbye, then call end_call.";
 
@@ -112,13 +119,9 @@ const IDLE_LINE =
  */
 const RELAY_MIC_MS = 15_000;
 
-/**
- * A line queued for the model. `mark` is the task id to mark reported once the
- * line is actually sent, not when it is queued.
- */
+/** A line queued for the model. */
 type Said = {
   line: string;
-  mark?: string;
   /** Shown on the activity line when the line is sent. */
   show?: ToolRun;
 };
@@ -132,8 +135,10 @@ export type ToolRun = {
   name: string;
   line: string | null;
   done: boolean;
-  /** A relay from a bot (report or question) rather than a tool; `name` is the task label. */
+  /** A relay from a bot (answer or question) rather than a tool; `name` is the task label. */
   kind?: "tool" | "relay";
+  /** The bot this names, when it names one: the row draws its face instead of a glyph. */
+  bot?: string | null;
 };
 
 export function useThursday() {
@@ -162,12 +167,16 @@ export function useThursday() {
     spoke: boolean;
     giveUp: ReturnType<typeof setTimeout> | null;
   }>({ tool: false, reading: false, spoke: false, giveUp: null });
-  /** Last activity time, and whether the goodbye was requested. */
+  /**
+   * Last activity time, whether the goodbye was requested, and when an answer
+   * started being owed (null once she answers or works).
+   */
   const idle = useRef<{
     since: number;
     asked: boolean;
+    owed: number | null;
     grace: ReturnType<typeof setTimeout> | null;
-  }>({ since: 0, asked: false, grace: null });
+  }>({ since: 0, asked: false, owed: null, grace: null });
   const linger = useRef<ReturnType<typeof setTimeout> | null>(null);
   // Every server-run tool in this call starts with this signal, so one abort
   // reaches running browser commands. Delegated tasks are server-owned and outlive the call
@@ -176,14 +185,15 @@ export function useThursday() {
   const callId = useRef<string | null>(null);
   /**
    * Relays sent this call, keyed by relayKey (id + updatedAt): an answered task
-   * comes back with reported=false and may ask again, so the id alone would
-   * silence its second question.
+   * can stop to ask again, so the id alone would silence its second question.
    */
   const relayed = useRef(new Set<string>());
+  /** When this call was placed. An ending from before it is already in her prompt. */
+  const placedAt = useRef(0);
   /**
    * Lines for the model, including ones raised before the line opens. Held
-   * until the session exists so nothing is marked reported unheard; this is
-   * also what lets a call-back queue its line first.
+   * until the session exists, which is also what lets a call-back queue its
+   * line first.
    */
   const outboxRef = useRef<Outbox<Said> | null>(null);
   const outbox = (outboxRef.current ??= createOutbox<Said>());
@@ -206,6 +216,7 @@ export function useThursday() {
     setTool({
       name: call.name,
       line: toolLine(call.name, call.arguments),
+      bot: toolBot(call.name, call.arguments),
       done: false,
     });
   }, []);
@@ -343,11 +354,15 @@ export function useThursday() {
     },
     tasks: () => void revalidate(queryKey.tasks),
     memory: () => void revalidate(queryKey.memory),
-    "memory-tidy": () => void revalidate(queryKey.memoryTidy),
     mcp: () => {
       void revalidate(queryKey.mcp);
       void revalidate(queryKey.mcpTools);
     },
+    // A sign-in finished in its own window (ai/chatgpt): the key rows and the model picker both read it
+    config: () => {
+      void revalidate(queryKey.config);
+      void revalidate(queryKey.llmModel);
+    },
   });
 
   // faces come from the bot list
@@ -356,23 +371,28 @@ export function useThursday() {
     if (tasks) botTasks.sync(tasks, bots);
   }, [tasks, bots]);
 
-  // Finished or waiting tasks are relayed once. Sending while the line is still
-  // opening is fine: the outbox holds the line. `status` is in deps because the
-  // guard is a ref; without it a list that arrived before the line opened
-  // would wait for the next tasks change
+  // A question is relayed on every call, because it still needs an answer. An
+  // ending is relayed only on the call it happened during: one from before is
+  // already in her prompt, on the `delegate` line that opened it. Telling is not
+  // seeing — the badge clears when the user opens the job. Sending while the
+  // line is still opening is fine: the outbox holds the line. `status` is in
+  // deps because the guard is a ref; without it a list that arrived before the
+  // line opened would wait for the next tasks change
   useEffect(() => {
     if (!tasks || !calling.current) return;
     for (const task of tasks) {
-      if (task.status === "running" || task.reported) continue;
+      if (task.status === "running") continue;
+      // A stop the app picks back up by itself is not news: it runs again in a moment
+      if (task.ask?.auto) continue;
+      if (
+        task.status !== "waiting" &&
+        toDate(task.updatedAt).getTime() < placedAt.current
+      )
+        continue;
       const key = relayKey(task);
       if (relayed.current.has(key)) continue;
       relayed.current.add(key);
-      // marked reported when the line is actually sent (outbox callback), not here
-      outbox.send({
-        line: relayLine(task),
-        mark: task.id,
-        show: relayShow(task),
-      });
+      outbox.send({ line: relayLine(task), show: relayShow(task) });
     }
   }, [tasks, outbox, status]);
 
@@ -385,7 +405,7 @@ export function useThursday() {
           line:
             act.kind === "answered"
               ? `The user answered task "${act.label}" on screen: ${act.answer}. The bot is going on with that — do not ask again.`
-              : `The user stopped task "${act.label}" on screen. It is not running any more — do not wait for it or report on it.`,
+              : `The user stopped task "${act.label}" on screen. It is not running any more — do not wait for it or say anything more about it.`,
         });
       }),
     [outbox],
@@ -401,7 +421,7 @@ export function useThursday() {
     calling.current = false;
     opening.current = false;
     relayed.current.clear();
-    // unsent lines belong to tasks still not reported; the next call resends them
+    // unsent lines go: a question is relayed again next call, an ending is in her prompt
     outbox.close();
     outbox.clear();
     // holds the closed session; the next call sets its own
@@ -414,7 +434,7 @@ export function useThursday() {
     // a pending face timer must not fire after the call
     restFace();
     if (idle.current.grace) clearTimeout(idle.current.grace);
-    idle.current = { since: 0, asked: false, grace: null };
+    idle.current = { since: 0, asked: false, owed: null, grace: null };
     setIdleLeft(null);
     setSince(null);
     setStatus("idle");
@@ -459,8 +479,17 @@ export function useThursday() {
    * agent activity does not, so the goodbye cannot cancel itself.
    */
   const stir = useCallback((who: "user" | "agent") => {
-    idle.current.since = Date.now();
-    if (who !== "user") return;
+    const now = Date.now();
+    idle.current.since = now;
+    if (who !== "user") {
+      // Words or a tool: she is on the line, so nothing is owed.
+      idle.current.owed = null;
+      return;
+    }
+    // Rewound by anything the user does, transcript deltas included, so a long
+    // turn is never mistaken for a line that stopped answering; it runs from the
+    // moment they stopped rather than from the moment they started.
+    idle.current.owed = now;
     if (idle.current.grace) clearTimeout(idle.current.grace);
     idle.current.grace = null;
     idle.current.asked = false;
@@ -473,6 +502,17 @@ export function useThursday() {
     const tick = setInterval(() => {
       const live = session.current;
       if (!live) return;
+      const owed = idle.current.owed;
+      if (owed !== null && Date.now() - owed >= AGENT_SILENT_MS) {
+        // Nothing to say goodbye with; the model is what would have said it.
+        toast.add({
+          type: "error",
+          title: "Call ended",
+          description: "The model stopped answering.",
+        });
+        void hangUp();
+        return;
+      }
       const left = IDLE_HANG_UP_MS - (Date.now() - idle.current.since);
       setIdleLeft(
         left <= IDLE_WARN_MS && !idle.current.asked
@@ -499,6 +539,7 @@ export function useThursday() {
     // from here on this is a call; the outbox holds lines until the session exists
     opening.current = true;
     calling.current = true;
+    placedAt.current = Date.now();
     outbox.clear();
     try {
       const handshake = unwrapResult(await openCallAction(thursdaySettings()));
@@ -601,8 +642,6 @@ export function useThursday() {
         live.say(queued.length === 1 ? queued[0].line : mergedRelay(queued));
         const last = queued.at(-1)?.show;
         if (last) showRelay(last);
-        const marks = queued.flatMap((one) => one.mark ?? []);
-        if (marks.length) markReported(marks);
         outbox.close();
       };
 
@@ -615,7 +654,7 @@ export function useThursday() {
       // line open: flush held lines first
       outbox.open((one) => flush([one]));
 
-      // First call: the opening system entry makes the model speak first, on the same path as a relay
+      // An opening — a first call, or memory to tidy — makes the model speak first, on the same path as a relay
       if (handshake.opening) {
         readAloud();
         live.say(handshake.opening);
@@ -669,7 +708,8 @@ export function useThursday() {
     if (!tasks) return;
     const wants = tasks.filter(
       (task) =>
-        !task.reported &&
+        !task.seen &&
+        !task.ask?.auto &&
         (asksSomething(task) ||
           (callBack === "any" && task.status !== "running")),
     );
@@ -809,25 +849,12 @@ function persistTurn(
     });
 }
 
-/** Failure surfaces as a toast: an unmarked report is read again next call. */
-function markReported(ids: string[]) {
-  markReportedAction(ids)
-    .then(unwrapResult)
-    .catch((cause) =>
-      toast.add({
-        type: "error",
-        title: "Could not mark the report as delivered",
-        description: errorToString(cause),
-      }),
-    );
-}
-
 /**
- * Waiting on a real question. A budget ask (out of steps) waits in the inbox
+ * Waiting on a real question. A job the app stopped waits in the inbox
  * instead of ringing.
  */
 function asksSomething(task: Task) {
-  return task.status === "waiting" && !isBudgetAsk(task.ask);
+  return task.status === "waiting" && !isAppStop(task.ask);
 }
 
 /**
@@ -835,16 +862,16 @@ function asksSomething(task: Task) {
  * sender and recipient or the model answers it as user speech.
  */
 function relayLine(task: Task) {
-  // The label travels with the report: what the user says next about this job
+  // The label travels with the answer: what the user says next about this job
   // is a word to it, and the task tool takes it by that name
   const from = `[${task.bot} → you, about "${task.label}" — not the user speaking; they have not heard this. Anything more on this job goes to the task tool as "${task.label}", never a new job.]`;
   switch (task.status) {
     case "waiting": {
-      // a budget ask is reported, not read as a question
+      // a stop is told, not read as a question
       const options = task.ask?.options ?? [];
       const said = task.ask?.question ?? task.outcome ?? "";
-      if (isBudgetAsk(task.ask)) {
-        return `${from} Out of steps. Where it got to: ${said} Ask whether to keep going; if yes, send "${TASK_CONTINUE}" with the task tool.`;
+      if (isAppStop(task.ask)) {
+        return `${from} It stopped before finishing. Where it got to: ${said} Ask whether to keep going; if yes, send "${TASK_CONTINUE}" with the task tool.`;
       }
       const list = options.length ? ` Options: ${options.join(" / ")}.` : "";
       return `${from} It asks: ${said}${list} Answer with the task tool if you can; otherwise ask the user and send back what they say.`;
@@ -852,7 +879,7 @@ function relayLine(task: Task) {
     case "failed":
       return `${from} It could not finish: ${task.outcome ?? ""}`;
     default:
-      return `${from} Done. Its report: ${task.outcome ?? ""}`;
+      return `${from} Done. Its answer: ${task.outcome ?? ""}`;
   }
 }
 
@@ -871,13 +898,13 @@ ${queued.map((one) => one.line).join("\n\n")}`;
 function relayShow(task: Task): ToolRun {
   const line =
     task.status === "waiting"
-      ? isBudgetAsk(task.ask)
-        ? `${task.bot} is out of steps`
+      ? isAppStop(task.ask)
+        ? `${task.bot} stopped`
         : `${task.bot} is asking`
       : task.status === "failed"
         ? `${task.bot} could not finish`
-        : `Report from ${task.bot}`;
-  return { kind: "relay", name: task.label, line, done: true };
+        : `Answer from ${task.bot}`;
+  return { kind: "relay", name: task.label, line, done: true, bot: task.bot };
 }
 
 export type { CallMessage, CallStatus };

package/features/workspace/components/file-view.tsx

@@ -158,10 +158,12 @@ export function FileLink({
 const PAD: Record<FileViewPlace, { prose: string; block: string }> = {
   dialog: { prose: "px-5 py-4", block: "px-4 py-3" },
   page: { prose: "px-5 py-6 sm:px-8", block: "px-5 py-5" },
+  // Opened under a list row, which already sets the edges
+  inline: { prose: "pb-3", block: "pb-3" },
 };
 
-/** Where the file is read: inside the dialog or on its own page. */
-export type FileViewPlace = "dialog" | "page";
+/** Where the file is read: inside the dialog, on its own page, or opened in place under a row. */
+export type FileViewPlace = "dialog" | "page" | "inline";
 
 export function FileBody({
   kind,

package/features/workspace/workspace.ts

@@ -14,9 +14,10 @@ import {
   DATA_DIR,
   PATHS,
   TOOL_OUTPUT,
+  WORKSPACE_KEEP,
 } from "@/config";
 import { logger } from "@/lib/logger";
-import { createSandBox, type Sandbox } from "@/lib/sandbox";
+import { createSandBox, type Sandbox, walkFiles } from "@/lib/sandbox";
 
 /**
  * Where the sandbox is opened. The app's own skills live outside the
@@ -225,6 +226,48 @@ export async function ensureBrowser(): Promise<void> {
   );
 }
 
+/** What a job leaves on disk: stale browser snapshots and spilled tool output. */
+export async function pruneJobFiles(): Promise<void> {
+  await pruneBrowserFiles();
+  await pruneOutputFiles();
+}
+
+type ListedBrowser = { name: string; headed?: boolean; attached?: boolean };
+
+/**
+ * A job that ended closes the browser nobody can see. Headless is the bot's
+ * working copy; `--headed` is the bot putting a window on their screen on
+ * purpose — an order at checkout, a map with a pin, a sign-in — and that one is
+ * theirs to close (`skills/browser`). A session attached to their own Chrome is
+ * never touched. Anything unreadable — no playwright, a failed or folded `list`
+ * — leaves the browser as it is.
+ */
+export async function closeHiddenBrowser(taskId: string): Promise<void> {
+  const sandbox = await openWorkspace();
+  const env = jobShellEnv(taskId);
+  const listed = await sandbox
+    .exec("playwright-cli list --json", { env, timeoutMs: 15_000 })
+    .catch(() => null);
+  let session: ListedBrowser | undefined;
+  try {
+    const { browsers } = JSON.parse(listed?.stdout ?? "") as {
+      browsers?: ListedBrowser[];
+    };
+    session = browsers?.find((b) => b.name === env.PLAYWRIGHT_CLI_SESSION);
+  } catch {}
+  if (session?.headed === false && !session.attached) {
+    await sandbox
+      .exec("playwright-cli close", { env, timeoutMs: 15_000 })
+      .catch(() => {});
+  }
+  await pruneJobFiles();
+}
+
+/**
+ * Closes the job's browser whatever it shows. Only for a job the user cancelled
+ * or deleted: its row is gone, so a window left open would belong to nothing on
+ * the screen.
+ */
 export async function closeJobShell(taskId: string): Promise<void> {
   const sandbox = await openWorkspace();
   await sandbox
@@ -233,20 +276,18 @@ export async function closeJobShell(taskId: string): Promise<void> {
       timeoutMs: 15_000,
     })
     .catch(() => {});
-  await pruneBrowserFiles();
-  await pruneOutputFiles();
+  await pruneJobFiles();
 }
 
-/**
- * playwright-cli never deletes its snapshot files. Refs go stale on the next
- * click, so anything older than an hour belongs to no running job.
- */
-const BROWSER_FILE_TTL_MS = 60 * 60 * 1000;
+const pruneOutputFiles = () => pruneOldFiles(PATHS.output);
+
+const pruneBrowserFiles = () => pruneOldFiles(BROWSER_DIR);
 
-async function pruneOutputFiles(): Promise<void> {
-  const dir = join(WORKSPACE, PATHS.output);
+/** Files directly in a workspace folder that have not changed for WORKSPACE_KEEP.forMs. */
+async function pruneOldFiles(folder: string): Promise<void> {
+  const dir = join(WORKSPACE, folder);
   const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-  const cutoff = Date.now() - OUTPUT_FILE_TTL_MS;
+  const cutoff = Date.now() - WORKSPACE_KEEP.forMs;
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const file = join(dir, entry.name);
@@ -255,24 +296,35 @@ async function pruneOutputFiles(): Promise<void> {
   }
 }
 
+/** Every folder under `scratch/`, workspace-relative, as jobScratch names them. */
+export async function listScratchFolders(): Promise<string[]> {
+  const entries = await readdir(join(WORKSPACE, PATHS.scratch), {
+    withFileTypes: true,
+  }).catch(() => []);
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => `${PATHS.scratch}/${entry.name}`);
+}
+
 /**
- * Tool output over `TOOL_OUTPUT.max` is written here in full and the model is
- * told where. Nothing read it after the run that made it, and nothing deleted
- * it either — a day is long enough to still be looking, short enough that the
- * folder does not become the biggest thing in the workspace.
+ * Removes the workspace folders among `folders` that have not changed for
+ * WORKSPACE_KEEP.forMs, judged by the folder itself. Only for folders no job owns
+ * (bot.runner sweepJobFiles): a job that has just made its folder is never old
+ * enough to be caught. Returns what went.
  */
-const OUTPUT_FILE_TTL_MS = 24 * 60 * 60 * 1000;
-
-async function pruneBrowserFiles(): Promise<void> {
-  const dir = join(WORKSPACE, BROWSER_DIR);
-  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-  const cutoff = Date.now() - BROWSER_FILE_TTL_MS;
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const file = join(dir, entry.name);
-    const info = await stat(file).catch(() => null);
-    if (info && info.mtimeMs < cutoff) await unlink(file).catch(() => {});
+export async function removeUnchangedFolders(
+  folders: string[],
+): Promise<string[]> {
+  const cutoff = Date.now() - WORKSPACE_KEEP.forMs;
+  const removed: string[] = [];
+  for (const folder of folders) {
+    const full = join(WORKSPACE, folder);
+    const info = await stat(full).catch(() => null);
+    if (!info?.isDirectory() || info.mtimeMs >= cutoff) continue;
+    await rm(full, { recursive: true, force: true }).catch(() => {});
+    removed.push(folder);
   }
+  return removed;
 }
 
 /**
@@ -304,6 +356,38 @@ export async function openWorkspace(): Promise<Sandbox> {
   });
 }
 
+/** Files read off one job's folder at most; a folder of generated files is not a list anyone reads. */
+const JOB_FOLDER_WALK = 500;
+
+/**
+ * What of a job's files is on disk: the paths it gave `write_file` that still exist,
+ * and every file under its own folder however it got there — a shell command, a
+ * download, a screenshot. Workspace-relative where inside the workspace, each once,
+ * the most recently changed last (bot.run filesUnder).
+ */
+export async function filesOnDisk(
+  written: string[],
+  folder: string | null,
+): Promise<string[]> {
+  const candidates = written.map((path) => resolve(WORKSPACE, path));
+  if (folder) {
+    let walked = 0;
+    for await (const full of walkFiles(join(WORKSPACE, folder))) {
+      candidates.push(full);
+      walked += 1;
+      if (walked >= JOB_FOLDER_WALK) break;
+    }
+  }
+  const found = new Map<string, number>();
+  for (const full of candidates) {
+    const info = await stat(full).catch(() => null);
+    if (!info?.isFile()) continue;
+    const rel = relative(WORKSPACE, full);
+    found.set(rel && !rel.startsWith("..") ? rel : full, info.mtimeMs);
+  }
+  return [...found].sort((a, b) => a[1] - b[1]).map(([path]) => path);
+}
+
 /**
  * Removes a job's working folder. Its lifetime is the task's: when the row goes,
  * so does what it was working with (features/bot/bot.runner). Never touches

package/lib/limits.ts

@@ -9,6 +9,6 @@ export const COMMON_VALIDATE = {
     max: 100,
   },
   prompt: {
-    max: 2000,
+    max: 4000,
   },
 };

package/lib/oauth-page.ts

@@ -0,0 +1,27 @@
+/**
+ * The page an OAuth redirect lands on: a detour tab that says how it went and closes itself
+ * when it went well. Every sign-in that comes back through a browser draws this one.
+ */
+export function oauthPage(
+  title: string,
+  detail: string,
+  { autoClose = false }: { autoClose?: boolean } = {},
+): string {
+  return `<!doctype html>
+<meta charset="utf-8">
+<title>${escapeHtml(title)}</title>
+<body style="font-family: ui-monospace, monospace; display: grid; place-items: center; min-height: 100dvh; margin: 0">
+  <div style="text-align: center; max-width: 28rem; padding: 1.5rem">
+    <p style="font-size: 1.125rem; margin: 0 0 .5rem">${escapeHtml(title)}</p>
+    <p style="color: #666; font-size: .875rem; margin: 0">${escapeHtml(detail)}</p>
+  </div>
+  ${autoClose ? "<script>setTimeout(() => window.close(), 900)</script>" : ""}
+</body>`;
+}
+
+function escapeHtml(text: string) {
+  return text
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}

package/lib/realtime/openai.ts

@@ -6,8 +6,8 @@ import { createWebRtcTransport } from "./realtime.transport";
 
 const CALLS_URL = "https://api.openai.com/v1/realtime/calls";
 
-/** Streams user transcripts as recognized; whisper-1 reports only after the turn ends. */
-const TRANSCRIPTION_MODEL = "gpt-4o-mini-transcribe";
+/** Streams user transcripts as recognized; the file models report only after the turn ends. */
+const TRANSCRIPTION_MODEL = "gpt-live-transcribe";
 
 export const createOpenAiSession = realtimeSession({
   transport: ({ credential, audio, on }) =>

package/lib/realtime/realtime.protocol.ts

@@ -46,7 +46,7 @@ export type OpenAiSessionConfig = {
   audio?: {
     input?: {
       format?: RealtimeAudioFormat;
-      /** Null turns transcription off. `whisper-1` reports only at turn end; `gpt-4o-*-transcribe` streams deltas. */
+      /** Null turns transcription off. A file model reports only at turn end; `gpt-live-transcribe` streams deltas. */
       transcription?: {
         model: string;
         language?: string;