thursday-agent 0.1.2 → 0.3.0

package/features/memory/components/memory-setting.tsx

@@ -12,6 +12,7 @@ import { Skeleton } from "@/components/ui/skeleton";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { Textarea } from "@/components/ui/textarea";
 import { PAGE_SIZE } from "@/config";
+import { MemoryEdit } from "@/features/memory/components/memory-edit";
 import {
   addFactsAction,
   createNoteAction,
@@ -25,6 +26,7 @@ import {
   isFading,
   type MemoryNote,
   type MemorySection,
+  memorySourceLabel,
   noteTitle,
   sectionOf,
 } from "@/features/memory/memory.schema";
@@ -45,7 +47,6 @@ const SECTIONS: { key: MemorySection; label: string }[] = [
   { key: "you", label: "You" },
   { key: "people", label: "People" },
   { key: "projects", label: "Projects" },
-  { key: "plans", label: "Plans" },
   { key: "topics", label: "Topics" },
   { key: "inbox", label: "Inbox" },
 ];
@@ -70,79 +71,83 @@ export function MemorySetting() {
   if (error) return <SettingError message={error.message} />;
 
   return (
-    <SettingPanes
-      footer={picked && <NoteReadLog note={picked} />}
-      left={
-        <div className="flex flex-col py-2">
-          <button
-            type="button"
-            onClick={openMemoryCreate}
-            className="mx-2 mb-1 flex items-center gap-2 rounded-md px-2 py-1.5 text-left text-[13px] text-muted-foreground outline-none hover:bg-muted/60 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:ring-inset"
-          >
-            <Plus className="size-3.5 shrink-0" />
-            New note
-          </button>
+    // The edit floats over the panes, above the rail (memory-edit)
+    <div className="relative h-full min-h-0">
+      <SettingPanes
+        footer={picked && <NoteReadLog note={picked} />}
+        left={
+          <div className="flex flex-col py-2">
+            <button
+              type="button"
+              onClick={openMemoryCreate}
+              className="mx-2 mb-1 flex items-center gap-2 rounded-md px-2 py-1.5 text-left text-[13px] text-muted-foreground outline-none hover:bg-muted/60 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:ring-inset"
+            >
+              <Plus className="size-3.5 shrink-0" />
+              New note
+            </button>
 
-          {SECTIONS.map(({ key, label }) => {
-            const rows = notes.filter((note) => sectionOf(note.path) === key);
-            if (rows.length === 0) return null;
+            {SECTIONS.map(({ key, label }) => {
+              const rows = notes.filter((note) => sectionOf(note.path) === key);
+              if (rows.length === 0) return null;
 
-            return (
-              <Fragment key={key}>
-                <span className="px-3 pt-3 pb-1 font-mono text-[10px] text-muted-foreground/60">
-                  {label}
-                  {key === "inbox" && (
-                    <span className="pl-1.5 text-muted-foreground/50">
-                      waiting to be filed
-                    </span>
-                  )}
-                </span>
-                {rows.map((note) => (
-                  <NoteLink
-                    key={note.id}
-                    note={note}
-                    active={note.id === picked?.id}
-                    onPick={() => setPickedId(note.id)}
-                  />
-                ))}
-              </Fragment>
-            );
-          })}
-          <SettingMore
-            hasMore={hasMore}
-            loading={isLoadingMore}
-            sentinelRef={sentinelRef}
-            count={3}
-            ghost={
-              <div className="mx-2 flex items-center gap-2 px-2 py-2">
-                <Skeleton className="h-3 w-28" />
-                <span className="flex-1" />
-                <Skeleton className="h-2.5 w-2.5" />
-              </div>
-            }
-          />
-        </div>
-      }
-      right={
-        picked ? (
-          // Keyed so editing state does not carry over to the next note.
-          <NotePage key={picked.id} note={picked} />
-        ) : (
-          <div className="space-y-4 p-8">
-            <p className="text-sm leading-relaxed text-muted-foreground">
-              During calls Thursday saves what it picks up — that a teammate
-              moved teams, that you take meetings in the morning — and reads it
-              back before answering. File the first note yourself and it starts
-              the next call already knowing something.
-            </p>
-            <Button variant="outline" onClick={openMemoryCreate}>
-              <Plus />
-              Add note
-            </Button>
+              return (
+                <Fragment key={key}>
+                  <span className="px-3 pt-3 pb-1 font-mono text-[10px] text-muted-foreground/60">
+                    {label}
+                    {key === "inbox" && (
+                      <span className="pl-1.5 text-muted-foreground/50">
+                        waiting to be filed
+                      </span>
+                    )}
+                  </span>
+                  {rows.map((note) => (
+                    <NoteLink
+                      key={note.id}
+                      note={note}
+                      active={note.id === picked?.id}
+                      onPick={() => setPickedId(note.id)}
+                    />
+                  ))}
+                </Fragment>
+              );
+            })}
+            <SettingMore
+              hasMore={hasMore}
+              loading={isLoadingMore}
+              sentinelRef={sentinelRef}
+              count={3}
+              ghost={
+                <div className="mx-2 flex items-center gap-2 px-2 py-2">
+                  <Skeleton className="h-3 w-28" />
+                  <span className="flex-1" />
+                  <Skeleton className="h-2.5 w-2.5" />
+                </div>
+              }
+            />
           </div>
-        )
-      }
-    />
+        }
+        right={
+          picked ? (
+            // Keyed so editing state does not carry over to the next note.
+            <NotePage key={picked.id} note={picked} />
+          ) : (
+            <div className="space-y-4 p-8">
+              <p className="text-sm leading-relaxed text-muted-foreground">
+                During calls Thursday saves what it picks up — that a teammate
+                moved teams, that you take meetings in the morning — and reads
+                it back before answering. File the first note yourself and it
+                starts the next call already knowing something.
+              </p>
+              <Button variant="outline" onClick={openMemoryCreate}>
+                <Plus />
+                Add note
+              </Button>
+            </div>
+          )
+        }
+      />
+      <MemoryEdit notes={notes} />
+    </div>
   );
 }
 
@@ -348,8 +353,16 @@ function NotePage({ note }: { note: MemoryNote }) {
                 <span className="flex-1 text-sm leading-relaxed text-foreground/90">
                   {fact.text}
                 </span>
-                <span className="shrink-0 pt-0.5 font-mono text-[11px] text-muted-foreground/50">
-                  {format(fact.createdAt, "yyyy.MM.dd")}
+                {/* When, and whose hand — memory is kept by four of them */}
+                <span className="shrink-0 pt-0.5 text-right text-[11px] text-muted-foreground/50">
+                  <span className="block font-mono">
+                    {format(fact.createdAt, "yyyy.MM.dd")}
+                  </span>
+                  {memorySourceLabel(fact.source) && (
+                    <span className="block">
+                      {memorySourceLabel(fact.source)}
+                    </span>
+                  )}
                 </span>
               </li>
             ))}
@@ -436,12 +449,6 @@ const NOTE_KINDS = [
     placeholder: "thursday",
     fact: "Ships behind a feature flag until April",
   },
-  {
-    key: "plans",
-    label: "Plan",
-    placeholder: "japan trip",
-    fact: "Aug 28–31 with Yuri — wedding rings in Ginza",
-  },
   {
     key: "topics",
     label: "Topic",

package/features/memory/memory.action.ts

@@ -1,7 +1,7 @@
 "use server";
 
 import { z } from "zod";
-import { parseTextModel } from "@/features/ai/model.schema";
+import { MEMORY_LIMITS } from "@/config";
 import {
   addFact,
   createNote,
@@ -11,15 +11,9 @@ import {
   setFactAlwaysLoad,
   updateNote,
 } from "@/features/memory/memory.query";
-import {
-  ALWAYS_LOADED_MAX,
-  isMemoryPath,
-} from "@/features/memory/memory.schema";
-import { markEveryCallRead } from "@/features/thursday/thursday.query";
+import { isMemoryPath } from "@/features/memory/memory.schema";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
-import { startTidy, stopTidy } from "./memory.tidy";
-import { readTidyOn, writeTidyModel, writeTidyOn } from "./tidy.query";
 
 const PathSchema = z.string().trim().refine(isMemoryPath, "Invalid note path");
 
@@ -84,43 +78,9 @@ export const setFactAlwaysLoadAction = serverAction(
     const result = await setFactAlwaysLoad(noteId, factId, alwaysLoad);
     if (result === "full") {
       publicError(
-        `Only ${ALWAYS_LOADED_MAX} facts can be carried into every call — drop one first`,
+        `Only ${MEMORY_LIMITS.carried} facts can be carried into every call — drop one first`,
       );
     }
     if (result === "missing") publicError("Fact not found");
   },
 );
-
-// Reading calls back (memory.tidy): the switch, the model, and the two hands on it.
-
-/** Switching on stamps every past call as read, so it starts from now rather than from the beginning of history. */
-export const setMemoryTidyOnAction = serverAction(async (on: unknown) => {
-  const wanted = z.boolean().parse(on);
-  if (wanted && !(await readTidyOn())) await markEveryCallRead();
-  await writeTidyOn(wanted);
-  if (!wanted) await stopTidy("Switched off.");
-});
-
-/** `provider/model`, or empty for the app default. */
-export const setMemoryTidyModelAction = serverAction(async (value: unknown) => {
-  const said = z.string().trim().parse(value);
-  if (!said) return writeTidyModel(null);
-  const ref = parseTextModel(said);
-  if (!ref) publicError("That is not a model this app can run.");
-  await writeTidyModel(ref);
-});
-
-/** The screen's "Read now": skips the count, not the read itself. */
-export const runMemoryTidyAction = serverAction(async () => {
-  const outcome = await startTidy({ force: true });
-  if (outcome === "off") publicError("Reading calls back is switched off.");
-  if (outcome === "no-model") {
-    publicError("Pick a model first — this does not run on the app default.");
-  }
-  if (outcome === "running") publicError("It is already reading.");
-  if (outcome === "nothing") publicError("Every call has been read back.");
-});
-
-export const cancelMemoryTidyAction = serverAction(async () => {
-  await stopTidy("Cancelled.");
-});

package/features/memory/memory.edit.ts

@@ -0,0 +1,87 @@
+import {
+  convertToModelMessages,
+  stepCountIs,
+  streamText,
+  validateUIMessages,
+} from "ai";
+import { ZodError, z } from "zod";
+import { loadTools } from "@/features/ai/load-tools";
+import { getTextModel, modelErrorToString } from "@/features/ai/model";
+import { textModelRefSchema } from "@/features/ai/model.schema";
+import { loadMemoryEditPrompt } from "@/features/ai/prompts/memory-edit.prompt";
+import { logger } from "@/lib/logger";
+import { isPublicError } from "@/lib/public-error";
+
+/**
+ * Editing memory from its own screen: one request, one streamed run. The model
+ * gets memory's two writes, which run as it calls them, and the page draws each
+ * call as it arrives. Nothing about the exchange is kept — the page holds the
+ * messages and drops them — so what lasts is only what the tools wrote.
+ */
+
+/** One line of intent: a run still writing after this many steps is not converging. */
+const MAX_STEPS = 20;
+
+const BodySchema = z.object({
+  model: textModelRefSchema,
+  messages: z.array(z.unknown()).min(1),
+});
+
+export async function streamMemoryEdit(
+  body: unknown,
+  signal: AbortSignal,
+): Promise<Response> {
+  let run: Awaited<ReturnType<typeof prepare>>;
+  try {
+    run = await prepare(body);
+  } catch (cause) {
+    // Nothing has streamed yet, so this text is what the page shows as the error
+    const { status, message } = startError(cause);
+    return new Response(message, { status });
+  }
+
+  const result = streamText({
+    model: run.model,
+    system: run.system,
+    messages: run.messages,
+    tools: run.tools,
+    // The first step has to write; after it the model stops once nothing is
+    // left. Required on every step would leave it no way to stop short of the cap.
+    prepareStep: ({ stepNumber }) => ({
+      toolChoice: stepNumber === 0 ? "required" : "auto",
+    }),
+    stopWhen: stepCountIs(MAX_STEPS),
+    abortSignal: signal,
+  });
+  // A provider's refusal is the user's to act on, so it is never masked
+  return result.toUIMessageStreamResponse({ onError: modelErrorToString });
+}
+
+async function prepare(body: unknown) {
+  const { model: ref, messages } = BodySchema.parse(body);
+  const tools = await loadTools({ target: "memory-edit" });
+  const [model, system, ui] = await Promise.all([
+    getTextModel(ref),
+    loadMemoryEditPrompt(),
+    validateUIMessages({ messages }),
+  ]);
+  return {
+    model: model.model,
+    system,
+    tools,
+    messages: await convertToModelMessages(ui),
+  };
+}
+
+/** The route boundary's policy (protocol/to-result), for a response that is not a Result. */
+function startError(cause: unknown): { status: number; message: string } {
+  if (isPublicError(cause)) return { status: 400, message: cause.message };
+  if (cause instanceof ZodError) {
+    return {
+      status: 400,
+      message: cause.issues[0]?.message ?? "That request does not fit",
+    };
+  }
+  logger.error(cause);
+  return { status: 500, message: "Could not start the edit" };
+}

package/features/memory/memory.query.ts

@@ -1,17 +1,17 @@
-import { and, asc, between, desc, eq, inArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
 import { appEvents } from "@/app/api/events/app-event.server";
-import { PAGE_SIZE } from "@/config";
+import { MEMORY_LIMITS, PAGE_SIZE } from "@/config";
 import { database } from "@/database/db";
-import { memoryFactTable, memoryNoteTable } from "@/database/tables";
+import { callTable, memoryFactTable, memoryNoteTable } from "@/database/tables";
 import { createKeyedLock } from "@/lib/queue";
 import {
-  ALWAYS_LOADED_MAX,
   isAlwaysListed,
   MEMORY_ALWAYS_LISTED,
   MEMORY_PATHS,
   type MemoryAlwaysLoaded,
   type MemoryNoteView,
   type MemoryNoteWrite,
+  type MemorySource,
   type MemoryWrite,
   recallScore,
 } from "./memory.schema";
@@ -68,9 +68,12 @@ function latestFacts(noteIds: number[]) {
       noteId: memoryFactTable.noteId,
       text: memoryFactTable.text,
       alwaysLoad: memoryFactTable.alwaysLoad,
+      source: memoryFactTable.source,
       createdAt: memoryFactTable.createdAt,
+      saidAt: callTable.startedAt,
     })
     .from(memoryFactTable)
+    .leftJoin(callTable, eq(memoryFactTable.callId, callTable.id))
     .where(
       and(
         eq(memoryFactTable.isLatest, true),
@@ -129,7 +132,8 @@ export async function deleteNote(id: number) {
 export async function addFact(noteId: number, text: string) {
   const [fact] = await database
     .insert(memoryFactTable)
-    .values({ noteId, text })
+    // Only the screen calls this, so the hand is known here (memory.action)
+    .values({ noteId, text, source: "user" })
     .returning();
   await touchNote(noteId);
   changed();
@@ -155,7 +159,7 @@ export async function reviseFact(noteId: number, factId: number, text: string) {
 
       const [fact] = await tx
         .insert(memoryFactTable)
-        .values({ noteId, text })
+        .values({ noteId, text, source: "user" })
         .returning();
       await tx
         .update(memoryNoteTable)
@@ -297,14 +301,18 @@ export async function readNotes(
       description: note.description,
       facts: facts
         .filter((fact) => fact.noteId === note.id)
-        .map((fact) => ({ id: fact.id, text: fact.text })),
+        .map((fact) => ({
+          id: fact.id,
+          text: fact.text,
+          ...(fact.saidAt ? { saidAt: fact.saidAt } : {}),
+        })),
     })),
     missing,
   };
 }
 
 /** Facts differing only in whitespace, punctuation or case count as the same fact. */
-export const sameFact = (text: string) =>
+const sameFact = (text: string) =>
   text.toLowerCase().replace(/[\s.,!?…·'"`]/g, "");
 
 /**
@@ -313,6 +321,10 @@ export const sameFact = (text: string) =>
  */
 export async function writeNotes(
   input: MemoryNoteWrite[],
+  /** Which hand is writing; recorded on every fact (memory.schema MemorySource). */
+  source: MemorySource,
+  /** The call it is being said in; null for the screen and for a bot. */
+  callId: string | null = null,
 ): Promise<MemoryWrite> {
   const unnamed: string[] = [];
   const paths: string[] = [];
@@ -321,7 +333,7 @@ export async function writeNotes(
 
   await serialize(() =>
     database.transaction(async (tx) => {
-      // Free alwaysLoad slots (ALWAYS_LOADED_MAX), counted inside the transaction.
+      // Free alwaysLoad slots (config MEMORY_LIMITS.carried), counted inside the transaction.
       const [loaded] = await tx
         .select({ count: sql<number>`count(*)` })
         .from(memoryFactTable)
@@ -331,7 +343,7 @@ export async function writeNotes(
             eq(memoryFactTable.isLatest, true),
           ),
         );
-      let room = ALWAYS_LOADED_MAX - Number(loaded?.count ?? 0);
+      let room = MEMORY_LIMITS.carried - Number(loaded?.count ?? 0);
 
       /** Claims an alwaysLoad slot; without one the fact is stored as ordinary. */
       const claim = (want: boolean, text: string) => {
@@ -466,6 +478,8 @@ export async function writeNotes(
                 .values({
                   noteId,
                   text: fact.text,
+                  source,
+                  callId,
                   alwaysLoad: claim(
                     fact.alwaysLoad ?? target.alwaysLoad,
                     fact.text,
@@ -494,6 +508,8 @@ export async function writeNotes(
             .values({
               noteId,
               text: fact.text,
+              source,
+              callId,
               alwaysLoad: claim(fact.alwaysLoad === true, fact.text),
             })
             .returning({
@@ -534,7 +550,7 @@ export function listAlwaysLoaded(): Promise<MemoryAlwaysLoaded[]> {
       ),
     )
     .orderBy(asc(memoryNoteTable.path), asc(memoryFactTable.id))
-    .limit(ALWAYS_LOADED_MAX);
+    .limit(MEMORY_LIMITS.carried);
 }
 
 /** Settings toggle for alwaysLoad; same cap as model writes, no new version. */
@@ -555,7 +571,7 @@ export async function setFactAlwaysLoad(
               eq(memoryFactTable.isLatest, true),
             ),
           );
-        if (Number(loaded?.count ?? 0) >= ALWAYS_LOADED_MAX) return "full";
+        if (Number(loaded?.count ?? 0) >= MEMORY_LIMITS.carried) return "full";
       }
 
       const [row] = await tx
@@ -678,41 +694,14 @@ export async function forgetFactById(
   return forgotten;
 }
 
-/** Facts written in a window, with their note: what a call already saved, so the tidy pass does not save it twice (memory.tidy). */
-export function listFactsWrittenBetween(
-  from: Date,
-  to: Date,
-): Promise<MemoryAlwaysLoaded[]> {
-  return database
-    .select({
-      id: memoryFactTable.id,
-      path: memoryNoteTable.path,
-      text: memoryFactTable.text,
-    })
-    .from(memoryFactTable)
-    .innerJoin(memoryNoteTable, eq(memoryFactTable.noteId, memoryNoteTable.id))
-    .where(
-      and(
-        eq(memoryFactTable.isLatest, true),
-        between(memoryFactTable.createdAt, from, to),
-      ),
-    )
-    .orderBy(asc(memoryFactTable.id));
-}
-
-/** One current fact with its note path; null when gone. */
-export async function findFactById(
+/** Who wrote a fact and the call it was said in; null when there is no such fact. */
+export async function findFactCall(
   id: number,
-): Promise<MemoryAlwaysLoaded | null> {
+): Promise<{ source: MemorySource | null; callId: string | null } | null> {
   const [fact] = await database
-    .select({
-      id: memoryFactTable.id,
-      path: memoryNoteTable.path,
-      text: memoryFactTable.text,
-    })
+    .select({ source: memoryFactTable.source, callId: memoryFactTable.callId })
     .from(memoryFactTable)
-    .innerJoin(memoryNoteTable, eq(memoryFactTable.noteId, memoryNoteTable.id))
-    .where(and(eq(memoryFactTable.id, id), eq(memoryFactTable.isLatest, true)));
+    .where(eq(memoryFactTable.id, id));
   return fact ?? null;
 }