thursday-agent 0.2.0 → 0.3.0

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;

package/lib/realtime/realtime.tap.ts

@@ -131,3 +131,125 @@ export function createAudioTap(): RealtimeAudio & {
     },
   };
 }
+
+/** What a face moves with on one frame (createVoiceFollower). */
+export type VoiceFrame = {
+  /** How far into its own range the voice is now, 0..1; 0 in silence. */
+  level: number;
+  /** `level` over about half a second: the phrase rather than the syllable. */
+  phrase: number;
+  /** Strength of a syllable that started on this frame; 0 when none did. */
+  onset: number;
+  /** Each band inside its own range, low to high; one the voice never reaches stays 0. */
+  bands: number[];
+};
+
+/** Seconds, except where a line says otherwise. */
+const FOLLOW = {
+  /** A band's ceiling jumps to a new peak and sinks back over `ceilRelease`. */
+  ceilAttack: 0.03,
+  ceilRelease: 2.5,
+  /** Its floor drops to the quiet between syllables and creeps back up over `floorRise`. */
+  floorFall: 0.12,
+  floorRise: 3,
+  /** A band whose range is narrower than this (0..1) carries no shape. */
+  minSpan: 0.12,
+  /** Mean band level (0..1) across which silence turns into voice. */
+  quietBelow: 0.03,
+  voicedAbove: 0.12,
+  fast: 0.05,
+  mid: 0.22,
+  phrase: 0.45,
+  /** A syllable: the fast level rises this far over the mid one, past `onsetMin`, at most once per `onsetGap`. */
+  onsetRise: 0.1,
+  onsetMin: 0.3,
+  onsetGap: 0.12,
+};
+
+/**
+ * Reads the voice's bands the way a face needs them. A voice is loud and narrow:
+ * its bands sit near the top and lean the same way for a whole sentence, so a
+ * face driven by them directly stays swollen and still. Here each band is
+ * followed inside its own recent range — the quiet between syllables is its
+ * floor, the syllables its ceiling — so the face moves with the words whatever
+ * the voice or its volume. One per face; it keeps state between frames.
+ */
+export function createVoiceFollower() {
+  const ceil = new Array<number>(SPECTRUM_BANDS).fill(0);
+  const floor = new Array<number>(SPECTRUM_BANDS).fill(0);
+  const frame: VoiceFrame = {
+    level: 0,
+    phrase: 0,
+    onset: 0,
+    bands: new Array<number>(SPECTRUM_BANDS).fill(0),
+  };
+  let fast = 0;
+  let mid = 0;
+  let sinceOnset = Number.POSITIVE_INFINITY;
+
+  const toward = (from: number, to: number, seconds: number, dt: number) =>
+    from + (to - from) * Math.min(1, dt / seconds);
+
+  return {
+    /** Call once per frame with the seconds since the last call. The frame returned is reused. */
+    read(input: ArrayLike<number>, dt: number): VoiceFrame {
+      let total = 0;
+      let within = 0;
+      let ranged = 0;
+      for (let k = 0; k < SPECTRUM_BANDS; k++) {
+        const x = input[k] ?? 0;
+        total += x;
+        ceil[k] = toward(
+          ceil[k],
+          x,
+          x > ceil[k] ? FOLLOW.ceilAttack : FOLLOW.ceilRelease,
+          dt,
+        );
+        floor[k] = toward(
+          floor[k],
+          x,
+          x < floor[k] ? FOLLOW.floorFall : FOLLOW.floorRise,
+          dt,
+        );
+        const span = ceil[k] - floor[k];
+        const at =
+          span > FOLLOW.minSpan
+            ? Math.min(1, Math.max(0, (x - floor[k]) / span))
+            : 0;
+        frame.bands[k] = at;
+        if (span > FOLLOW.minSpan) {
+          within += at;
+          ranged++;
+        }
+      }
+
+      const mean = total / SPECTRUM_BANDS;
+      const edge = Math.min(
+        1,
+        Math.max(
+          0,
+          (mean - FOLLOW.quietBelow) / (FOLLOW.voicedAbove - FOLLOW.quietBelow),
+        ),
+      );
+      const voiced = edge * edge * (3 - 2 * edge);
+      for (let k = 0; k < SPECTRUM_BANDS; k++) frame.bands[k] *= voiced;
+
+      frame.level = (ranged ? within / ranged : 0) * voiced;
+      fast = toward(fast, frame.level, FOLLOW.fast, dt);
+      mid = toward(mid, frame.level, FOLLOW.mid, dt);
+      frame.phrase = toward(frame.phrase, frame.level, FOLLOW.phrase, dt);
+
+      sinceOnset += dt;
+      frame.onset = 0;
+      if (
+        fast > mid + FOLLOW.onsetRise &&
+        fast > FOLLOW.onsetMin &&
+        sinceOnset > FOLLOW.onsetGap
+      ) {
+        sinceOnset = 0;
+        frame.onset = Math.min(1, fast);
+      }
+      return frame;
+    },
+  };
+}

package/lib/sandbox.ts

@@ -1,17 +1,10 @@
 import { spawn } from "node:child_process";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve as pathResolve, relative, sep } from "node:path";
+import { EXEC_KILL_GRACE_MS, EXEC_TIMEOUT_MS } from "@/config";
 
 export type ExecResult = { stdout: string; stderr: string; exitCode: number };
 
-/**
- * How long one command may run before its process group is killed. Nobody is
- * watching the shell, so a command waiting on a prompt would otherwise hang
- * the job; anything that legitimately runs longer belongs in the background.
- * Named because the shell guide states it to the model (ai/tools/workspace.tool).
- */
-export const EXEC_TIMEOUT_MS = 180_000;
-
 export interface Sandbox {
   /** Absolute. Relative paths resolve from here */
   readonly cwd: string;
@@ -61,6 +54,25 @@ const IGNORE = new Set([
   "coverage",
 ]);
 
+/**
+ * Every file under `dir`, skipping dot entries and the folders a build or a
+ * package manager fills (IGNORE). A folder that cannot be read yields nothing.
+ */
+export async function* walkFiles(dir: string): AsyncGenerator<string> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (IGNORE.has(e.name) || e.name.startsWith(".")) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) yield* walkFiles(full);
+    else if (e.isFile()) yield full;
+  }
+}
+
 /**
  * Environment for every shell the agent runs: nobody watches it, so no pager
  * may stall it, and secrets do not travel to children. playwright-cli runs
@@ -108,21 +120,6 @@ export const createSandBox = ({
   const res = (p: string) =>
     p.startsWith("/") || /^[A-Za-z]:/.test(p) ? p : pathResolve(cwd, p);
 
-  async function* walk(dir: string): AsyncGenerator<string> {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (IGNORE.has(e.name) || e.name.startsWith(".")) continue;
-      const full = join(dir, e.name);
-      if (e.isDirectory()) yield* walk(full);
-      else if (e.isFile()) yield full;
-    }
-  }
-
   // A very simple glob → regex. Only **/, * and ? are supported
   const globToRe = (g: string) =>
     new RegExp(
@@ -155,7 +152,7 @@ export const createSandBox = ({
       const root = res(path);
       const re = globToRe(pattern);
       const out: string[] = [];
-      for await (const f of walk(root)) {
+      for await (const f of walkFiles(root)) {
         const rel = relative(root, f).split(sep).join("/");
         if (re.test(rel) || re.test(f)) out.push(f);
         if (out.length >= limit) break;
@@ -180,28 +177,26 @@ export const createSandBox = ({
         child.stdout?.on("data", (d) => (stdout += d));
         child.stderr?.on("data", (d) => (stderr += d));
 
-        const stop = (why: string) => {
-          stderr += `\n[${why}]`;
+        const group = (name: NodeJS.Signals) => {
           try {
             // A negative pid means the group: the shell and everything under it
-            if (child.pid) process.kill(-child.pid, "SIGTERM");
+            if (child.pid) process.kill(-child.pid, name);
           } catch {
             // Already gone, or no process groups on this platform
-            child.kill("SIGTERM");
+            child.kill(name);
           }
         };
 
-        const timer = setTimeout(
-          () => stop(`Timed out after ${timeoutMs}ms`),
-          timeoutMs,
-        );
-
-        const onAbort = () => stop("Aborted");
-        if (signal?.aborted) onAbort();
-        else signal?.addEventListener("abort", onAbort, { once: true });
+        let settled = false;
+        let killing: ReturnType<typeof setTimeout> | undefined;
+        let letGo: ReturnType<typeof setTimeout> | undefined;
 
         const done = async (result: ExecResult) => {
+          if (settled) return;
+          settled = true;
           clearTimeout(timer);
+          clearTimeout(killing);
+          clearTimeout(letGo);
           signal?.removeEventListener("abort", onAbort);
           resolve({
             ...result,
@@ -210,6 +205,34 @@ export const createSandBox = ({
           });
         };
 
+        const stop = (why: string) => {
+          if (killing || settled) return;
+          stderr += `\n[${why}]`;
+          group("SIGTERM");
+          // A command that ignores SIGTERM would hold its step, and everything
+          // waiting on the job, for good (config EXEC_KILL_GRACE_MS)
+          killing = setTimeout(() => {
+            stderr += "\n[Killed: it did not exit on SIGTERM]";
+            group("SIGKILL");
+            // Output held open by a process that left the group never closes;
+            // what arrived by now is the result
+            letGo = setTimeout(() => {
+              child.stdout?.destroy();
+              child.stderr?.destroy();
+              void done({ stdout, stderr, exitCode: -1 });
+            }, 1_000);
+          }, EXEC_KILL_GRACE_MS);
+        };
+
+        const timer = setTimeout(
+          () => stop(`Timed out after ${timeoutMs}ms`),
+          timeoutMs,
+        );
+
+        const onAbort = () => stop("Aborted");
+        if (signal?.aborted) onAbort();
+        else signal?.addEventListener("abort", onAbort, { once: true });
+
         child.on("close", (code) =>
           done({ stdout, stderr, exitCode: code ?? -1 }),
         );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thursday-agent",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A voice agent that runs on your own machine — talk to her, she hands the slow work to bots with a shell, a browser and skills.",
   "license": "MIT",
   "keywords": [

package/skills/browser/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: browser
-description: "Any browser and anything on the web — a page, a click, a form, a sign-in, a tab. Open a page and read it, fill a form, sign in, download, screenshot, print a page or an HTML file to PDF. This opens a real window on their screen, and it is how a browser is reached even when one is already running on their Mac (`attach`) — a browser is never driven by clicking it through the machine. A page that wants a sign-in is still this skill's job: the user signs in themselves, in the window this opens."
+description: "Any browser and anything on the web — a page, a click, a form, a sign-in, a tab. Open a page and read it, fill a form, sign in, download, screenshot, print a page or an HTML file to PDF. It can put a real window on their screen to show them the thing itself — an order at checkout, a map, a page — and it is how a browser is reached even when one is already running on their Mac (`attach`) — a browser is never driven by clicking it through the machine. A page that wants a sign-in is still this skill's job: a kept session, the browser they are already in, or the window this opens in front of them."
 allowed-tools: Bash(playwright-cli:*) Bash(npx:*) Bash(npm:*)
 ---
 
@@ -15,8 +15,8 @@ Everything the app has to say about the browser is here; the prompts do not
 repeat it.
 
 **Every browser goes through here.** A job that names a browser, a site, a URL,
-a sign-in or a tab is this one's. The window `playwright-cli` opens is a real
-one on their screen — they can watch it and type into it. Never drive Chrome by
+a sign-in or a tab is this one's. With `--headed` the window `playwright-cli`
+opens is a real one on their screen — they can watch it and type into it. Never drive Chrome by
 clicking it through the machine (`osascript`, `peekaboo`, System Events): that
 window cannot be snapshotted or acted on by ref. For the browser they already
 have open — a tab they left, a profile they are signed into — attach instead:
@@ -24,13 +24,27 @@ have open — a tab they left, a profile they are signed into — attach instead
 
 **Your browser is this job's own.** Its session is already in your shell
 (`PLAYWRIGHT_CLI_SESSION`): never pass `-s=`, never `close-all` or `kill-all` —
-other jobs are running theirs. The server closes yours when the job ends.
-
-**Headless unless they should see it.** Add `--headed` when the window is the
-point — a sign-in, something they asked to watch — and say so in your
-`description`. A site that will want a session before it shows you anything — a
-shop, a console, a dashboard, an account page — starts `--headed --persistent`
-rather than finding out headless and starting over.
+other jobs are running theirs.
+
+**Headless is yours; headed is theirs.** A browser opens headless: nobody sees
+it, and the app closes it when the job ends. `--headed` puts a real window on
+their screen, and that window outlives the job — the app never closes it, they
+do. So you can show them the thing itself instead of describing it: the order
+sitting at checkout for them to confirm, the map with the pin dropped, the page
+they asked to watch, a sign-in for them to finish. Open it `--headed`, leave it
+open, and say in your answer that it is on their screen. A window you opened
+headed only to get past a wall and are done with, `close` yourself. Only a job
+they cancel or delete takes its windows with it.
+
+**A payment is theirs to press.** Take a purchase, a top-up or a subscription
+as far as the last screen before money moves, open it `--headed`, and answer
+with what it buys, for how much, and that the pay button is on their screen.
+That is the job done, not stopped — never press it yourself, whatever the
+request said.
+
+A site that will want a session before it shows you anything — a shop, a
+console, a dashboard, an account page — starts `--headed --persistent` rather
+than finding out headless and starting over.
 
 **Blocked, not broken.** A 403, an "access denied" page, a wall about automated
 traffic is refusing the headless browser, not the job. `close`, then
@@ -39,29 +53,36 @@ most of it, and is worth trying before you conclude anything about the site.
 Still refused after that, the wall is real: say so in your report, with the url
 and whatever you did bring back.
 
-**A sign-in is not a wall.** The user is at this screen and signs in
-themselves, in a window you put in front of them. Never type a password, a
-one-time code, or answer a passkey prompt — not with `fill`, `type` or `eval`.
-An email or username they gave you is not a secret: fill it, press next, stop
-at the password. When you do not have it, look before you ask — `memory_recall`
-the note for that site or account carries the address they use; only when it is
-nowhere does the sign-in go back to them. When a page wants the secret half:
-
-```bash
-playwright-cli close
-playwright-cli open <the login url> --headed --persistent
-```
-
-Open the login page itself, not the front door. Then `ask_thursday` in one
-line — what to sign into, that the window is open — with options
-`Signed in` / `Not now`, and stop. The window stays open while the job waits.
-When the answer comes back, continue from a fresh `snapshot`. A captcha is the
-same move. Never `show` — it blocks waiting for annotations nobody will send.
-
-**Keep a sign-in for the next job.** After one succeeds:
-`state-save .auth/<site>.json`. Before a site that will want one, `ls .auth/`
-and `state-load .auth/<site>.json` if its file is there. These files never go
-in a report.
+**A sign-in is a fork, not a wall.** Four ways through, and which one fits is
+yours to read off the job:
+
+- **A session you already kept.** `ls <your folder>/.auth/`, then `state-load`
+  that file and `goto` the site — cookies without a reload leave the signed-out
+  page that was already drawn, which reads as an expired session when it is not.
+  Cheapest when it works, so look before anything else.
+- **The browser they are already in.** `attach --cdp=chrome` carries their own
+  profile and whatever it is signed into.
+- **They sign in themselves.** `open <the login url> --headed --persistent` —
+  the login page, not the front door — then `ask_thursday` in one line saying
+  what to sign into and that the window is open, options `Signed in` / `Not
+  now`, and stop. The window stays open while the job waits; continue from a
+  fresh `snapshot` when the answer comes. A captcha is the same move. Not
+  `show` — it blocks waiting for annotations nobody will send.
+- **You have the credentials.** Ask before you use them: `ask_thursday` in one
+  line naming the account, options `Sign in with it` / `I'll do it`, and on the
+  second take the fork above. An answer to your own sign-in question is the
+  exception — credentials given there are already the yes, so type them.
+
+The line is where the secret comes from, not what kind it is: never guess,
+invent, or go looking for one somewhere they did not point you at. An email or
+username they gave you is not a secret — fill it and press next. `memory_recall`
+the note for that site when you are missing the address they use.
+
+**Keep a sign-in for the next job.** `mkdir -p <your folder>/.auth` and
+`state-save` into it after one succeeds — your own folder, the one your
+instructions name, because a session is yours across jobs and the workspace root
+is nobody's. Say that you kept it: it signs every later job in as them, which is
+theirs to want or not. These files never go in a report.
 
 **Reading a page.** Every command writes a snapshot file and prints its path.
 `find "Create Key"` returns only the matching nodes with a few lines around
@@ -87,7 +108,7 @@ A click that seems to do nothing may have opened a tab: `tab-list`,
 `goto http://127.0.0.1:48800/<file>.html`; `pdf --filename=out.pdf` prints
 it. Kill the server when done.
 
-Snapshots land in `.playwright-cli/` and are cleared after an hour. A file you
+Snapshots land in `.playwright-cli/` and are cleared after a few days. A file you
 name — `--filename=`, a `pdf`, a download — goes under `scratch/`, or
 `artifacts/` when it is the result.
 

package/.next/server/app/api/bot/notes/route/app-paths-manifest.json

@@ -1,3 +0,0 @@
-{
-  "/api/bot/notes/route": "app/api/bot/notes/route.js"
-}