thursday-agent 0.2.0 → 0.3.0

package/features/memory/memory.schema.ts

@@ -2,13 +2,12 @@ import { z } from "zod";
 import { type DateLike, DateLikeSchema, toDate } from "@/lib/date-like";
 
 /**
- * Who put a fact here. Memory is one note kept by four hands — the user typing
- * on the screen, the call as they talk, a bot that turned something up mid-job,
- * and the pass that reads calls back afterwards — and they are not equally
- * close to the user. A reader that cannot tell them apart reads what a bot
- * inferred as something the user said.
+ * Who put a fact here. Memory is one note kept by three hands — the user typing
+ * on the screen, the call as they talk, and a bot that turned something up
+ * mid-job — and they are not equally close to the user. A reader that cannot
+ * tell them apart reads what a bot inferred as something the user said.
  */
-export const MemorySourceSchema = z.enum(["user", "call", "bot", "tidy"]);
+export const MemorySourceSchema = z.enum(["user", "call", "bot"]);
 
 export type MemorySource = z.infer<typeof MemorySourceSchema>;
 
@@ -25,15 +24,13 @@ export const memorySourceLabel = (source: MemorySource | null | undefined) =>
       ? "on a call"
       : source === "bot"
         ? "a bot"
-        : source === "tidy"
-          ? "read back"
-          : "";
+        : "";
 
 // Storage is fact-based: one row per fact, history via isLatest.
 export const MemoryFactSchema = z.object({
   id: z.number(),
   text: z.string(),
-  /** Loaded into every prompt without opening the note (ALWAYS_LOADED_MAX). */
+  /** Loaded into every prompt without opening the note (config MEMORY_LIMITS.carried). */
   alwaysLoad: z.boolean(),
   /** Null on rows written before the hand was recorded. */
   source: MemorySourceSchema.nullish(),
@@ -65,17 +62,16 @@ export type MemoryNote = z.infer<typeof MemoryNoteSchema>;
 export const MEMORY_PATHS = [
   {
     path: "profile",
-    of: "The user themselves — who they are, what they do, where, how they live",
+    of: "The user themselves — their name, age, what they do, where they live, and whatever else says who they are",
   },
-  { path: "preferences", of: "How they like things done, and said" },
+  { path: "preferences", of: "How they want things done, and said" },
+  { path: "people/", of: "Someone in their life, and what matters about them" },
   {
-    path: "people/",
-    of: "Who someone is to them, and what matters about them",
+    path: "projects/",
+    of: "Something with an end — a trip, a purchase, a deadline, a thing being built",
   },
-  { path: "projects/", of: "Something they are building or running" },
-  { path: "plans/", of: "A trip, an appointment, a purchase, a deadline" },
-  { path: "topics/", of: "Anything else worth its own note" },
-  { path: "inbox", of: "Nowhere obvious to go" },
+  { path: "topics/", of: "Something ongoing that keeps coming back" },
+  { path: "inbox", of: "Nowhere obvious yet" },
 ] as const;
 
 /** Where anything outside the convention lands. */
@@ -92,7 +88,6 @@ export const MEMORY_SECTIONS = MEMORY_PATHS.filter((entry) =>
 ).map((entry) => entry.path.slice(0, -1)) as (
   | "people"
   | "projects"
-  | "plans"
   | "topics"
 )[];
 
@@ -108,11 +103,20 @@ export const MEMORY_ALWAYS_LISTED: string[] = ["profile", "preferences"];
 export const isAlwaysListed = (path: string) =>
   MEMORY_ALWAYS_LISTED.includes(path);
 
-/** Threshold, not a cap: a note above this is flagged for tidying but never truncated. */
-export const MANY_FACTS = 100;
+/**
+ * Notes whose listing line the app writes rather than a model: the two root
+ * notes it keeps (memory.query ensureRootNotes) and the inbox, which is where
+ * a fact lands when its path is not one this listing can carry. A model's
+ * `description` for one of these is ignored, so the line cannot drift with
+ * whoever wrote last (ai/tools/memory.tool).
+ */
+export const APP_NAMED_NOTES = [...MEMORY_ALWAYS_LISTED, MEMORY_INBOX];
+
+export const isAppNamed = (path: string) => APP_NAMED_NOTES.includes(path);
 
-/** Max facts loaded into every session prompt; enforced by the write path, not the prompt. */
-export const ALWAYS_LOADED_MAX = 14;
+/** The line the app writes for one of those. */
+export const appNoteLine = (path: string) =>
+  MEMORY_PATHS.find((entry) => entry.path === path)?.of ?? null;
 
 export type MemorySection =
   | "you"
@@ -134,6 +138,8 @@ export type MemoryFactRef = {
   /** What `memory_forget` and `replaces` take. */
   id: number;
   text: string;
+  /** When the call it was said in started, when a call wrote it. Formatted by the tool, never sent as a Date. */
+  saidAt?: Date;
 };
 
 /** A fact carried at the top of the prompt, with its note path. */
@@ -209,86 +215,3 @@ export function isFading(
 ): boolean {
   return !isAlwaysListed(note.path) && recallScore(note) < 0.15;
 }
-
-// Reading calls back (memory.tidy): its settings and the run row the screen draws.
-
-/** Config keys (features/config config.query) the settings live under. */
-export const MEMORY_TIDY_KEYS = {
-  /** "on" switches it on; anything else, unset included, is off. */
-  on: "MEMORY_TIDY",
-  /** `provider/model`; unset runs on the app default (ai/model resolveDefaultModel). */
-  model: "MEMORY_TIDY_MODEL",
-} as const;
-
-/**
- * Off unless switched on. A read costs a whole context of a text model, so
- * nothing starts spending until the user asks for it — and a model must be
- * picked as well (memory.tidy startTidy).
- */
-export const isTidyOn = (value: string | undefined) => value?.trim() === "on";
-
-export const MEMORY_TIDY_STATUSES = [
-  "running",
-  "done",
-  "stopped",
-  "failed",
-] as const;
-export type MemoryTidyStatus = (typeof MEMORY_TIDY_STATUSES)[number];
-
-/** One thing a read changed; the run row keeps them in order. */
-export const MemoryTidyChangeSchema = z.object({
-  op: z.enum(["add", "replace", "forget", "carry", "uncarry"]),
-  path: z.string(),
-  text: z.string(),
-});
-export type MemoryTidyChange = z.infer<typeof MemoryTidyChangeSchema>;
-
-export const MemoryTidyRunSchema = z.object({
-  id: z.string(),
-  status: z.enum(MEMORY_TIDY_STATUSES),
-  provider: z.string(),
-  model: z.string(),
-  /** The calls this read covered and stamped, oldest first. */
-  callIds: z.string().array(),
-  /** Turns it actually read. Fewer than were owed when older ones were dropped. */
-  messages: z.number(),
-  changes: MemoryTidyChangeSchema.array(),
-  error: z.string().nullable(),
-  inputTokens: z.number(),
-  outputTokens: z.number(),
-  startedAt: DateLikeSchema,
-  endedAt: DateLikeSchema.nullable(),
-});
-export type MemoryTidyRun = z.infer<typeof MemoryTidyRunSchema>;
-
-/** What the setting reads (app/api/memory/tidy). */
-export type MemoryTidyStatusView = {
-  on: boolean;
-  /** The picked model as `provider/model`, or null for the app default. */
-  model: string | null;
-  /** Turns said since the last read, and how many it takes to run. */
-  pending: number;
-  every: number;
-  /** The read in progress, if any. */
-  current: MemoryTidyRun | null;
-  /** The most recent finished read. */
-  last: MemoryTidyRun | null;
-};
-
-/** Counts per op for one line on screen: "3 added, 1 revised". */
-export function tidyTally(changes: MemoryTidyChange[]): string {
-  const count = (op: MemoryTidyChange["op"]) =>
-    changes.filter((change) => change.op === op).length;
-  const said = (
-    [
-      [count("add"), "added"],
-      [count("replace"), "revised"],
-      [count("forget"), "dropped"],
-      [count("carry"), "carried"],
-      [count("uncarry"), "uncarried"],
-    ] as const
-  )
-    .filter(([n]) => n > 0)
-    .map(([n, word]) => `${n} ${word}`);
-  return said.length ? said.join(", ") : "nothing to change";
-}

package/features/settings/components/settings.tsx

@@ -29,6 +29,7 @@ import { BotBadge } from "@/features/bot/components/bot-badge";
 import { BotsMark } from "@/features/bot/components/bot-mark";
 import { TaskBadge } from "@/features/bot/components/task-badge";
 import { ConfigBadge } from "@/features/config/components/config-badge";
+import { ModelsBadge } from "@/features/config/components/models-badge";
 import { McpBadge } from "@/features/connectors/components/mcp-badge";
 import { McpMark } from "@/features/connectors/components/mcp-mark";
 import { MemoryMark } from "@/features/memory/components/memory-mark";
@@ -203,6 +204,7 @@ export const SECTIONS: readonly {
     hint: "What bots draw, film, speak and transcribe with",
     icon: Aperture,
     Component: ModelsSetting,
+    Badge: ModelsBadge,
   },
   {
     id: "config",

package/features/settings/settings.alert.ts

@@ -3,6 +3,7 @@
 import { useBotAlert } from "@/features/bot/components/bot-badge";
 import { useTaskAlert } from "@/features/bot/components/task-badge";
 import { useConfigAlert } from "@/features/config/components/config-badge";
+import { useModelsAlert } from "@/features/config/components/models-badge";
 import { useMcpAlert } from "@/features/connectors/components/mcp-badge";
 import type { SettingSectionId } from "./settings.store";
 
@@ -32,5 +33,6 @@ export function useSectionAlerts(): Partial<
   const tasks = useTaskAlert();
   const mcp = useMcpAlert();
   const config = useConfigAlert();
-  return { bot, tasks, mcp, config };
+  const models = useModelsAlert();
+  return { bot, tasks, mcp, config, models };
 }

package/features/thursday/components/ascii-orb.tsx

@@ -1,6 +1,11 @@
 "use client";
 
 import { useEffect, useRef } from "react";
+import { ASCII_FACE } from "@/config";
+import {
+  createVoiceFollower,
+  SPECTRUM_BANDS,
+} from "@/lib/realtime/realtime.tap";
 import {
   ALPHA_TOP,
   CHAR_RATE,
@@ -132,44 +137,47 @@ const DESIGN = 680;
 /** Radius (reference units) within which cells exist. Must stay under DESIGN/2 or the canvas clips it. */
 const FIELD_R = 328;
 
-/** Gain on incoming band values: speech bands average 0.15-0.35, and the top is clamped anyway. */
-const VOICE_GAIN = 2.6;
-
 /** Speaking: reference-unit px the rim is pushed by each channel. */
-/** Swell at average loudness 1 */
-const SPEAK_SWELL = 58;
+/** Where the rim sits while the voice is at the bottom of its range */
+const SPEAK_BASE = 184;
+/** Swell across a phrase at the top of the voice's range */
+const SPEAK_SWELL = 40;
 /** Kick per syllable */
-const SPEAK_KICK = 58;
+const SPEAK_KICK = 120;
 /** Rotating lobes, harmonics 2 and up (the first harmonic shifts the whole circle) */
 const SPEAK_LOBES = 4;
 /** Max depth of one lobe */
-const SPEAK_LOBE_R = 40;
+const SPEAK_LOBE_R = 34;
 /**
- * Rim range. Max must stay inside FIELD_R or outgoing rings die at the edge;
- * min keeps a deep breath from collapsing to a dot.
+ * Rim range. Past SPEAK_KNEE the rim slows into SPEAK_MAX rather than stopping
+ * at it, so a loud syllable still reads as a push instead of a flat edge. Max
+ * stays inside FIELD_R or thrown crumbs die at the edge; min keeps a deep
+ * breath from collapsing to a dot.
  */
 const SPEAK_MIN = 130;
+const SPEAK_KNEE = 244;
 const SPEAK_MAX = 278;
-/** Syllable ring speed (px/s) and lifetime (s) */
-const RING_SPEED = 100;
-const RING_LIFE = 0.55;
-/** Rings alive at once, so fast speech does not flood the field */
+/** How far a rim cell sits in or out of the rim: the edge is crumbly, not drawn with a compass */
+const SPEAK_ROUGH = 20;
+/** Share of cells a syllable throws outward; the rest stay, so what leaves is crumbs, not a ring */
+const SPECK_SHARE = 0.22;
+/** Crumb speed (px/s) and lifetime (s) */
+const RING_SPEED = 90;
+const RING_LIFE = 0.7;
+/** Syllables in flight at once, so fast speech does not flood the field */
 const MAX_RINGS = 5;
 
 /** Per-frame values derived from the voice; every cell reads the same ones. */
 type Voice = {
-  /** Three time constants; fast/mid detect syllables, slow sets size */
-  fast: number;
-  mid: number;
-  slow: number;
+  /** The voice inside its own range over about half a second (realtime.tap createVoiceFollower) */
+  phrase: number;
   /** Spring kicked by each syllable */
   bob: number;
   bobVel: number;
-  lastOnset: number;
   /** Lobe strength and angle */
   amp: number[];
   phase: number[];
-  /** One outgoing ring per syllable */
+  /** One throw of crumbs per syllable */
   rings: { born: number; power: number }[];
 };
 
@@ -228,6 +236,8 @@ type Cell = {
   death: number;
   /** Emoji slot in emoji mode */
   emoji: boolean;
+  /** Below SPECK_SHARE, a crumb a syllable throws outward */
+  speck: number;
   /** Index of the ERROR letter this cell belongs to, or -1 */
   letter: number;
 };
@@ -276,6 +286,13 @@ function idleValue(cell: Cell, t: number) {
   return (0.58 + w * 0.2 + breath) * body;
 }
 
+/** The rim's radius for a raw push: as pushed up to SPEAK_KNEE, then easing into SPEAK_MAX. */
+function rimAt(raw: number) {
+  if (raw <= SPEAK_KNEE) return Math.max(SPEAK_MIN, raw);
+  const room = SPEAK_MAX - SPEAK_KNEE;
+  return SPEAK_KNEE + room * Math.tanh((raw - SPEAK_KNEE) / room);
+}
+
 /**
  * Brightness of one mode; mode transitions blend two of these.
  * @param e seconds since the mode started
@@ -305,12 +322,16 @@ function valueFor(m: AsciiOrbMode, cell: Cell, t: number, e: number, v: Voice) {
      * Speaking. Frequency is not mapped to angle: a voice's spectrum barely
      * moves within a sentence, so that freezes into a fixed star. The voice
      * gives size, syllables and lobe strength; rotation comes from time, each
-     * lobe at its own speed in alternating directions.
+     * lobe at its own speed in alternating directions. No line in it is clean:
+     * the rim is crumbly, and a syllable throws crumbs rather than a ring.
      */
     case "speaking": {
       const grow = smoothstep(0, 1, Math.min(1, e / 0.8));
 
-      let raw = IDLE_R + (SPEAK_SWELL * v.slow + SPEAK_KICK * v.bob) * grow;
+      let raw =
+        IDLE_R +
+        (SPEAK_BASE - IDLE_R + SPEAK_SWELL * v.phrase + SPEAK_KICK * v.bob) *
+          grow;
       for (let i = 0; i < SPEAK_LOBES; i++) {
         raw +=
           SPEAK_LOBE_R *
@@ -318,26 +339,41 @@ function valueFor(m: AsciiOrbMode, cell: Cell, t: number, e: number, v: Voice) {
           Math.sin((i + 2) * cell.angle + v.phase[i]) *
           grow;
       }
-      const edge = Math.max(SPEAK_MIN, Math.min(SPEAK_MAX, raw));
-
-      const d = cell.dist - edge;
-      const rim = Math.exp(-(d * d) / 900);
-      const core = Math.exp(-(cell.dist * cell.dist) / 6000) * 0.55;
-      const inside = cell.dist < edge ? 0.3 * (1 - cell.dist / edge) ** 0.6 : 0;
-
-      // one ring per syllable, born at the rim and moving outward
+      const edge = rimAt(raw);
+
+      // each cell sits a little in or out of the rim, and the offset drifts
+      const rough =
+        (cell.grain - 0.5) * SPEAK_ROUGH +
+        Math.sin(cell.angle * 5 + t * 0.9 + cell.seed * 6.283) *
+          SPEAK_ROUGH *
+          0.3;
+      const d = cell.dist - (edge + rough);
+      const rim = Math.exp(-(d * d) / 800);
+      const core = Math.exp(-(cell.dist * cell.dist) / 6000) * 0.5;
+      // a soft fill toward the center, with the idle wave still moving through it
+      const inside =
+        cell.dist < edge
+          ? 0.3 *
+            (1 - cell.dist / edge) ** 0.6 *
+            (0.75 + 0.25 * Math.sin(cell.dist * 0.05 - t * 1.2))
+          : 0;
+
+      // crumbs: a sparse share of cells, each thrown past the rim at its own speed
       let out = 0;
-      for (let i = 0; i < v.rings.length; i++) {
-        const ring = v.rings[i];
-        const age = t - ring.born;
-        const dd = cell.dist - (edge + age * RING_SPEED);
-        out +=
-          Math.exp(-(dd * dd) / 2200) *
-          ring.power *
-          Math.max(0, 1 - age / RING_LIFE);
+      if (cell.speck < SPECK_SHARE) {
+        const speed = RING_SPEED * (0.6 + cell.grain * 0.9);
+        for (let i = 0; i < v.rings.length; i++) {
+          const ring = v.rings[i];
+          const age = t - ring.born;
+          const dd = cell.dist - (edge + 6 + age * speed);
+          out +=
+            Math.exp(-(dd * dd) / 500) *
+            ring.power *
+            Math.max(0, 1 - age / RING_LIFE);
+        }
       }
 
-      return rim + core + inside + out * 0.8;
+      return rim + core + inside + out;
     }
 
     /**
@@ -387,10 +423,10 @@ function valueFor(m: AsciiOrbMode, cell: Cell, t: number, e: number, v: Voice) {
 export function AsciiOrb({
   className,
   mode = "idle",
-  charset = "ascii",
+  charset = ASCII_FACE.charset,
   emotion = null,
-  fontSize = 8,
-  density = 1.4,
+  fontSize = ASCII_FACE.fontSize.default,
+  density = ASCII_FACE.density.default,
   size = DESIGN,
   color = DEFAULT_COLOR,
   getSpectrum,
@@ -432,12 +468,9 @@ export function AsciiOrb({
   specRef.current = getSpectrum;
 
   const voiceRef = useRef<Voice>({
-    fast: 0,
-    mid: 0,
-    slow: 0,
+    phrase: 0,
     bob: 0,
     bobVel: 0,
-    lastOnset: -Infinity,
     amp: new Array<number>(SPEAK_LOBES).fill(0),
     // distinct start phases, or the lobes overlap into one lump at first
     phase: Array.from({ length: SPEAK_LOBES }, (_, i) => i * 2.1),
@@ -502,6 +535,7 @@ export function AsciiOrb({
           birth: hash(c * 3.1 + 7, r * 5.7 + 2),
           death: hash(c * 9.4 + 3, r * 2.6 + 8),
           emoji: hash(c * 2.7 + 31, r * 5.9 + 17) < EMOJI_RATIO,
+          speck: hash(c * 4.1 + 23, r * 6.3 + 41),
           letter,
         });
       }
@@ -583,8 +617,8 @@ export function AsciiOrb({
   // animation loop
   useEffect(() => {
     let raf = 0;
-    const BINS = 28;
-    const spec = new Array<number>(BINS);
+    const follower = createVoiceFollower();
+    const murmur = new Array<number>(SPECTRUM_BANDS).fill(0);
 
     let lastT = performance.now() * 0.001;
 
@@ -604,49 +638,27 @@ export function AsciiOrb({
       bk.asciiN.fill(0);
       bk.emojiN.fill(0);
 
-      // Live voice when available. Bands (usually 8) are fewer than BINS (28)
-      // and the orb reads this array by angle, so interpolate to avoid steps
-      const live = specRef.current?.();
-      if (live && live.length > 1) {
-        const last = live.length - 1;
-        for (let i = 0; i < BINS; i++) {
-          // fold the band index so it returns to the first band over one revolution; a plain stretch shows a seam at 0 degrees
-          const fold = Math.abs((((i / BINS) * 2 + 1) % 2) - 1);
-          const at = fold * last;
-          const lo = Math.floor(at);
-          const hi = Math.min(last, lo + 1);
-          spec[i] = live[lo] + (live[hi] - live[lo]) * (at - lo);
-        }
-      } else {
-        for (let i = 0; i < BINS; i++) {
+      // Live voice when available; without one a murmur keeps the orb alive (previews)
+      let live: ArrayLike<number> | undefined = specRef.current?.();
+      if (!live || live.length < 2) {
+        for (let k = 0; k < murmur.length; k++) {
           const a =
-            Math.sin(t * 1.7 + i * 1.7) * 0.5 +
-            Math.sin(t * 0.8 + i * 0.6) * 0.3 +
-            Math.sin(t * 3.0 + i * 2.9) * 0.2;
-          spec[i] = a * 0.5 + 0.5;
+            Math.sin(t * 1.7 + k * 1.7) * 0.5 +
+            Math.sin(t * 0.8 + k * 0.6) * 0.3 +
+            Math.sin(t * 3.0 + k * 2.9) * 0.2;
+          murmur[k] = a * 0.5 + 0.5;
         }
+        live = murmur;
       }
 
-      // derive size, syllables and lobes from the voice (once per frame)
+      // size, syllables and lobes from the voice, once per frame; each band is
+      // read inside its own range, or a voice's narrow loud spectrum pins the rim
       const voice = voiceRef.current;
-      let loud = 0;
-      for (let i = 0; i < BINS; i++) loud += spec[i];
-      loud = Math.min(1, (loud / BINS) * VOICE_GAIN);
-
-      // three time constants: a syllable is a frame above the recent average, not a loud frame
-      voice.fast += (loud - voice.fast) * 0.3;
-      voice.mid += (loud - voice.mid) * 0.06;
-      voice.slow += (loud - voice.slow) * 0.02;
-
-      if (
-        voice.fast > voice.mid * 1.25 + 0.02 &&
-        voice.fast > 0.07 &&
-        t - voice.lastOnset > 0.14
-      ) {
-        voice.lastOnset = t;
-        const power = Math.min(1, voice.fast * 1.7);
-        voice.bobVel += 0.05 * power;
-        voice.rings.push({ born: t, power });
+      const heard = follower.read(live, dt);
+      voice.phrase = heard.phrase;
+      if (heard.onset > 0) {
+        voice.bobVel += 0.06 * heard.onset;
+        voice.rings.push({ born: t, power: heard.onset });
         if (voice.rings.length > MAX_RINGS) voice.rings.shift();
       }
       // a spring with a period of about 1s; kick it on syllables instead of driving position, or 60fps noise becomes jitter
@@ -654,15 +666,19 @@ export function AsciiOrb({
       voice.bob += voice.bobVel;
 
       for (let i = 0; i < SPEAK_LOBES; i++) {
-        const from = ((i / SPEAK_LOBES) * BINS) | 0;
-        const to = (((i + 1) / SPEAK_LOBES) * BINS) | 0;
+        // neighbouring bands per lobe, low lobes from low bands
+        const from = Math.floor((i * heard.bands.length) / SPEAK_LOBES);
+        const to = Math.max(
+          from + 1,
+          Math.floor(((i + 1) * heard.bands.length) / SPEAK_LOBES),
+        );
         let energy = 0;
-        for (let j = from; j < to; j++) energy += spec[j];
-        energy = Math.min(1, (energy / Math.max(1, to - from)) * VOICE_GAIN);
+        for (let j = from; j < to; j++) energy += heard.bands[j];
+        energy /= to - from;
         // a random factor that changes about once per second, so lobes keep moving through a held vowel
         const wander = 0.7 + hash(((t * 0.9) | 0) + i * 31, i) * 0.6;
         // different time constants per harmonic, or the star only scales
-        voice.amp[i] += (energy * wander - voice.amp[i]) * (0.02 + i * 0.012);
+        voice.amp[i] += (energy * wander - voice.amp[i]) * (0.05 + i * 0.02);
         // own speed, alternating direction, so no standing wave forms
         voice.phase[i] += dt * (0.5 + i * 0.37) * (i % 2 ? -1 : 1);
       }

package/features/thursday/components/boot.tsx

@@ -63,6 +63,13 @@ export function Boot({
       }}
     >
       <AsciiField boot rim={face.rim} centerY={face.centerY} onSettled={lift} />
+
+      {/* Nothing here can lift the curtain without the client, so a load that
+          never hydrates is a blank screen. Revealed by CSS alone (globals.css
+          `stalled`), well after any healthy start. */}
+      <p className="absolute inset-x-0 bottom-16 animate-stalled text-center text-[13px] text-muted-foreground opacity-0">
+        The page did not start. Reload it.
+      </p>
     </div>
   );
 }