agentbox-app 0.1.7 → 0.1.12

package/main/store.mjs

@@ -12,12 +12,14 @@ import { answerFor, describeFor } from './first-run.mjs';
 import { checkProjectFolder } from '../shared/project-folder-check.mjs';
 import { EXAMPLES, stampsFor } from '../shared/first-run-examples.mjs';
 import {
-  PRACTICE_ANSWER, PRACTICE_FLAG, PRACTICE_NAME, PRACTICE_NOTE, PRACTICE_ROWS, PRACTICE_SLUG,
-  PRACTICE_TASK_TRACE,
+  PRACTICE_ANSWER, PRACTICE_BACKDROP, PRACTICE_FLAG, PRACTICE_NAME, PRACTICE_NOTE, PRACTICE_ROWS, PRACTICE_SLUG,
+  PRACTICE_REPLY_ANSWER, PRACTICE_TASK_TRACE,
 } from '../shared/first-run-practice.mjs';
 import { NOTE_NAME } from './rail-note.mjs';
 import { iconPathFor } from './project-identity.mjs';
+import { patchProjectAt } from './store/project.mjs';
 import { imgUrl } from './img-scheme.mjs';
+import { teamOf, PERSONAL_FLAG } from './team/projects.mjs';
 import {
   agentImportRow, agentsNeedingRows, threadImportRow, threadsNeedingRows,
 } from '../shared/agent-import.mjs';
@@ -66,7 +68,12 @@ export class Store {
   /* ------------------------------- products ------------------------------ */
   // A product is a project directory under the account root carrying a
   // project.json. Archived products (or the reserved analytics id) don't ride.
-  listProducts() {
+  // ARCHIVED PROJECTS ARE LEFT OUT unless a caller asks for them, which is
+  // what makes archiving one take it off the inbox, the sidebar, the fleet and
+  // the Projects page in one write. Two callers do ask: the Projects page, so
+  // an archived one can be brought back, and the team sync, which must still
+  // count a shared project you archived as here or it joins it a second time.
+  listProducts({ includeArchived = false } = {}) {
     const root = this.config.accountRoot;
     let entries = [];
     try {
@@ -93,9 +100,10 @@ export class Store {
       } catch {
         continue;
       }
-      if (project.archived) continue;
+      if (project.archived && !includeArchived) continue;
       products.push({
         slug: entry.name,
+        ...(includeArchived ? { archived: project.archived === true } : {}),
         dir,
         name: project.name || entry.name,
         oneLiner: project.oneLiner || '',
@@ -117,11 +125,56 @@ export class Store {
         // that turn on this flag — never spawning a worker in it, drawing a
         // band over it — must never happen to real work.
         practice: project[PRACTICE_FLAG] === true,
+        // YOUR PERSONAL PROJECT, where a thread is Only you unless you say
+        // otherwise (main/team/projects.mjs, w-b989839656).
+        personal: project[PERSONAL_FLAG] === true,
+        // WHO SEES ITS THREADS on the Team page (w-b989839656), read as
+        // written; shared/thread-cards.mjs projectSeenBy is the one reading.
+        ...(typeof project.seenBy === 'string' ? { seenBy: project.seenBy } : {}),
+        ...(Array.isArray(project.seenByPeople) ? { seenByPeople: project.seenByPeople.filter((p) => typeof p === 'string') } : {}),
+        // SHARED OR PRIVATE. Null on a private project, which is every
+        // project of a person who never signs in; otherwise the cloud id that
+        // is the same on every teammate's Mac (main/team/projects.mjs).
+        team: teamOf(project),
       });
     }
     return products.sort((a, b) => a.name.localeCompare(b.name));
   }
 
+  /** ARCHIVE A PROJECT, OR BRING ONE BACK. One flag in its project.json and
+   *  nothing else: the folder, its documents and its threads stay on disk, and
+   *  `listProducts` is what stops showing it. Agents already running there
+   *  finish; nothing new starts, because the fleet reads the same list.
+   *
+   *  Resolved through the list itself, so the only thing this can ever write
+   *  is a project folder directly inside this account, named exactly. */
+  setProductArchived(slug, archived) {
+    const product = slug ? this.listProducts({ includeArchived: true }).find((p) => p.slug === slug) : null;
+    if (!product) throw new Error('That project could not be found.');
+    if (product.archived !== (archived === true)) {
+      patchProjectAt(product.dir, { archived: archived === true });
+      // The watched folders are the listed ones, so one brought back is not
+      // watched until the list is read again.
+      if (this.watchers.length) this.watch();
+    }
+    return { slug, archived: archived === true };
+  }
+
+  /** WHO SEES A PROJECT'S THREADS on the Team page (w-b989839656): 'private'
+   *  (Just you), 'team', or 'people' with the people named. Written into the
+   *  project's own file, because it is the project's, and nothing of the
+   *  project itself leaves this Mac either way. My Workspace is refused: it is
+   *  Just you by what it is. */
+  setProductSeenBy(slug, { who, people } = {}) {
+    const product = slug ? this.listProducts({ includeArchived: true }).find((p) => p.slug === slug) : null;
+    if (!product) throw new Error('That project could not be found.');
+    if (product.personal) throw new Error('My Workspace is always just you.');
+    if (who !== 'private' && who !== 'team' && who !== 'people') throw new Error(`unknown setting for who sees it: ${who}`);
+    const ids = [...new Set((Array.isArray(people) ? people : []).filter((p) => typeof p === 'string' && p))];
+    patchProjectAt(product.dir, { seenBy: who, seenByPeople: who === 'people' ? ids : undefined });
+    return { slug, who, people: who === 'people' ? ids : [] };
+  }
+
   /* ------------------------------ work items ----------------------------- */
   // The cross-product fold. Every item carries its product slug so the
   // renderer can group, filter, and rail without a second lookup.
@@ -149,6 +202,23 @@ export class Store {
     return all;
   }
 
+  // THE NEXT PAGE OF FINISHED THREADS THE SNAPSHOT'S 8 MB READ LEFT OUT
+  // (`readOlderWorkItems`), newest finished first, for the Done and All tabs
+  // as she scrolls to their foot (w-fda2165ec6). Archived projects stay out,
+  // as they do of `listItems`.
+  listOlderItems({ offset = 0, limit = 50, now = Date.now() } = {}) {
+    const { workItemsDisk } = this.modules;
+    const all = [];
+    for (const product of this.listProducts()) {
+      let items = [];
+      try { items = workItemsDisk.readOlderWorkItems(product.dir, now); } catch { continue; }
+      for (const item of items) all.push({ ...item, product: product.slug, productName: product.name });
+    }
+    const finished = (i) => i.wrote?.status?.ts || i.updatedAt;
+    all.sort((a, b) => finished(b) - finished(a));
+    return { items: all.slice(offset, offset + limit), more: all.length > offset + limit };
+  }
+
   // One item, folded fresh off disk. The supervisor holds a SPAWN-TIME snapshot
   // for the whole life of a session, so it cannot ask what the session did to
   // the row without reading it again; that question is the difference between a
@@ -254,7 +324,11 @@ export class Store {
   //
   // Undefined means she never opened the drawer and the row keeps what it had.
   // Null means she cleared it, and the engine chooses again.
-  answerItem(slug, id, { answer, status, priority, permissionMode, model, effort }) {
+  //
+  // `inReplyTo` makes the answer a reply in a thread (w-920461cbe6): the uid
+  // of the message it answers, on THE SAME LINE as the words, so the reply's
+  // own uid (what its reactions hang off) is the line that says where it goes.
+  answerItem(slug, id, { answer, status, priority, permissionMode, model, effort, inReplyTo }) {
     const { workItemsDisk } = this.modules;
     const dir = this.productDir(slug);
     let item = null;
@@ -269,7 +343,7 @@ export class Store {
     // special-cased in both engines' argument builders.
     if (model !== undefined) item = workItemsDisk.updateWorkItem(dir, id, { model: model ?? '' }, { source: 'founder' });
     if (effort !== undefined) item = workItemsDisk.updateWorkItem(dir, id, { effort: effort ?? '' }, { source: 'founder' });
-    if (answer) item = workItemsDisk.updateWorkItem(dir, id, { answer }, { source: 'founder' });
+    if (answer) item = workItemsDisk.updateWorkItem(dir, id, inReplyTo ? { answer, inReplyTo } : { answer }, { source: 'founder' });
     // The pane may still show a running row after Stop or a provider result.
     // Resolve omitted reply status against the ledger that was just written.
     if (status == null && typeof answer === 'string' && answer.trim() && answer !== '(withdrawn)'
@@ -308,6 +382,28 @@ export class Store {
     return workItemsDisk.updateWorkItem(dir, id, { status }, { source: 'system' });
   }
 
+  // THE APP SHIPPED A TASK, OR COULD NOT (main/ship-queue.mjs). Both are the
+  // app's own words, so both go in as 'system', as a note: the reply field is
+  // hers. A failure reopens the row, and the queue hands the script's words
+  // straight to the agent that wrote the change.
+  shipped(slug, id, { sha, labels }) {
+    const { workItemsDisk } = this.modules;
+    const dir = this.productDir(slug);
+    const note = sha ? `Shipped to main as ${sha}.` : 'Shipped to main.';
+    return workItemsDisk.updateWorkItem(dir, id, { labels, note }, { source: 'system' });
+  }
+
+  shipFailed(slug, id, { note, labels }) {
+    const { workItemsDisk } = this.modules;
+    const dir = this.productDir(slug);
+    workItemsDisk.updateWorkItem(dir, id, { labels, note }, { source: 'system' });
+    return workItemsDisk.updateWorkItem(dir, id, { status: 'open' }, { source: 'system' });
+  }
+
+  releaseRunClaim(slug, id, run) {
+    return this.modules.workItemsDisk.releaseRunClaim(this.productDir(slug), id, run);
+  }
+
   // THE WRITTEN NAME THE LIST DRAWS. Written by the app rather than by a
   // session, on agent authority, and never onto `title`: the title is what she
   // typed and the fold keeps it hers (main/row-label.mjs says why at length).
@@ -320,6 +416,15 @@ export class Store {
     return workItemsDisk.updateWorkItem(this.productDir(slug), id, { label: clean }, { source: 'agent' });
   }
 
+  // How urgent a teammate's message is, as the sorter judged it
+  // (main/message-priority.mjs). On agent authority, so a level the person set
+  // by hand stays theirs.
+  prioritizeItem(slug, id, value) {
+    const { workItemsDisk } = this.modules;
+    if (!Number.isFinite(value)) return null;
+    return workItemsDisk.updateWorkItem(this.productDir(slug), id, { priority: value }, { source: 'agent' });
+  }
+
   // A one-off permission mode has been spent. Called by the supervisor at the
   // moment it launches the run that mode was set for, so a mode she chose for
   // one message cannot silently govern a respawn three hours later.
@@ -366,10 +471,7 @@ export class Store {
   // app restart, a reboot, and a store restored onto another machine, and so no
   // agent line can quietly move a time she set. 0 clears it.
   //
-  // This is the one write behind both gestures: deferring an agent's proposal
-  // out of the inbox and scheduling her own work to start at six. They were
-  // separate mechanisms before, and only the first existed: the old snooze was
-  // a renderer localStorage map that hid a row and deferred no work at all.
+  // Execution scheduling only. Inbox reminders use snoozeItem instead.
   scheduleItem(slug, id, runAt) {
     const { workItemsDisk } = this.modules;
     return workItemsDisk.updateWorkItem(
@@ -377,7 +479,50 @@ export class Store {
     );
   }
 
-  composeItem(slug, { title, body, kind = 'directive', priority = 0, labels, runAt, engine, model, effort }) {
+  // Put the existing thread back in the person's inbox later. This never
+  // changes its execution schedule, answer, status, claim or delivery marks.
+  snoozeItem(slug, id, snoozedUntil) {
+    if (!Number.isFinite(snoozedUntil)) throw new Error('Snooze needs a valid time');
+    return this.modules.workItemsDisk.updateWorkItem(
+      this.productDir(slug), id, { snoozedUntil: Math.max(0, Math.trunc(snoozedUntil)) }, { source: 'founder' },
+    );
+  }
+
+  // WHO A SHARED ROW IS WITH, changed by a person: handed to an agent, kept,
+  // handed back, or passed on by a reply. Only the team fields, on the
+  // person's own authority, so an agent writing afterwards cannot undo it.
+  teamPatch(slug, id, patch) {
+    const allowed = Object.fromEntries(Object.entries(patch ?? {}).filter(([k]) => ['assignee', 'runner', 'due', 'people'].includes(k)));
+    if (!Object.keys(allowed).length) throw new Error('nothing to change');
+    return this.modules.workItemsDisk.updateWorkItem(this.productDir(slug), id, allowed, { source: 'founder' });
+  }
+
+  // A REACTION ON ONE MESSAGE (w-560647d4db): the chips under it in a chat.
+  // `on` is the uid of the ledger line the message was written as, which is the
+  // one name for a message that is the same on every teammate's Mac. Written as
+  // the person's own word, and appended like anything else: the fold keeps a
+  // press per person rather than one value per row, so two people reacting at
+  // the same moment keep both chips (shared/work-items.mjs).
+  react(slug, id, { on, emoji, off = false }) {
+    return this.modules.workItemsDisk.updateWorkItem(
+      this.productDir(slug), id, { react: off ? { on, emoji, off: true } : { on, emoji } }, { source: 'founder' },
+    );
+  }
+
+  // AN EDIT TO A THREAD FROM ITS SUMMARY (approved 2026-10-01): the summary's
+  // three lines and its links, who sees it, and its priority. Written as the
+  // person's own words; on the summary the later write wins either way
+  // (SHARED_FIELDS in shared/work-items.mjs).
+  threadEdit(slug, id, patch) {
+    // `start` is how a thread leaves Later: the summary and the thread page
+    // both write 'now' on it, which is what makes `isDue` true again.
+    const fields = ['problem', 'progress', 'solution', 'visibility', 'visibleTo', 'priority', 'blockedBy', 'blocks', 'start'];
+    const allowed = Object.fromEntries(Object.entries(patch ?? {}).filter(([k]) => fields.includes(k)));
+    if (!Object.keys(allowed).length) throw new Error('nothing to change');
+    return this.modules.workItemsDisk.updateWorkItem(this.productDir(slug), id, allowed, { source: 'founder' });
+  }
+
+  composeItem(slug, { title, body, kind = 'directive', priority = 0, labels, runAt, start, engine, model, effort, assignee, due, people, visibility, visibleTo }) {
     const { workItemsDisk } = this.modules;
     const dir = this.productDir(slug);
     // The 'founder' label is the human-in-the-loop marker: only items the
@@ -396,6 +541,9 @@ export class Store {
       title,
       ...(body ? { body } : {}),
       ...(runAt ? { runAt: Math.max(0, Math.trunc(runAt)) } : {}),
+      // "Add it to Later" on the card: the thread exists now and starts when
+      // she says, which is the one answer on that menu with no clock in it.
+      ...(start === 'later' ? { start: 'later' } : {}),
       // WHICH MODEL SHE CHOSE FOR THIS ONE, on founder authority like the rest
       // of her content (2026-08-26).It is a Claude Code alias, and the spawn
       // hands it to `--model`.
@@ -417,8 +565,27 @@ export class Store {
       // whole gate exists for. Whether the word may be written at all is decided
       // before it gets here, by `Supervisor#engineOffered`.
       ...(engine ? { engine: String(engine) } : {}),
+      // A TASK GIVEN TO A PERSON (the team version): who has to do it and
+      // when. No agent runs on it until that person hands it to one
+      // (shared/team-rules.mjs), and it reaches their inbox, not the sender's.
+      ...(assignee ? { assignee: String(assignee) } : {}),
+      ...(due ? { due: String(due) } : {}),
+      ...(Array.isArray(people) && people.length ? { people } : {}),
+      // WHO SEES IT (approved 2026-10-01): the team by default, nobody but its
+      // owner, or the people she chose (w-41ff964775). No field at all reads
+      // as the team, except in your personal project, where it reads as Only
+      // you (w-b989839656). So Team is written when it was chosen, which is
+      // how a thread in My Workspace is shared on purpose.
+      ...(visibility === 'private' || visibility === 'team' ? { visibility } : {}),
+      ...(visibility === 'people' && Array.isArray(visibleTo) && visibleTo.length
+        ? { visibility, visibleTo: [...new Set(visibleTo.map(String))] } : {}),
     };
-    return workItemsDisk.updateWorkItem(dir, created.id, contentPatch, { source: 'founder' });
+    // WITH ITS PROJECT ON IT, the way `readItem` answers. The fold never carries
+    // one, and the renderer withdraws a just-made task with `made.product`, so
+    // without this Z after a send asked for "no such product: undefined" and
+    // reached past the task to whatever was under it (w-c78d1e1607).
+    const made = workItemsDisk.updateWorkItem(dir, created.id, contentPatch, { source: 'founder' });
+    return made ? { ...made, product: slug } : made;
   }
 
   /* ---------------------------- repeating tasks --------------------------- */
@@ -508,6 +675,9 @@ export class Store {
       name,
       createdAt: new Date().toISOString(),
       ...(repo ? { repoPath: repo } : {}),
+      // EVERY NEW PROJECT STARTS AS JUST YOU (w-b989839656): its threads
+      // reach the Team page only once you share the project or the thread.
+      seenBy: 'private',
     }, null, 2));
     // AND IT FILES NOTHING INTO HER INBOX.
     //
@@ -761,6 +931,47 @@ export class Store {
     return { ids };
   }
 
+  /**
+   * THE REST OF THE PRACTICE TEAM'S WORK, so the tour and the board are not
+   * empty (w-58c8f466e7). The copy, and which column each row lands in, is
+   * `PRACTICE_BACKDROP` in shared/first-run-practice.mjs. The ids come back in
+   * its order, which is how `walkRows` knows which one is which.
+   *
+   *  The column is the app's own reading of the row, so each is written in the
+   *  shape that reads that way and nothing marks it: a finished one has a
+   *  result, a working one is her ask with a run and no result yet, and the
+   *  scheduled one is her ask with a time in the future, set as hers. */
+  stagePracticeBackdrop(slug, { now = Date.now(), label = 'first-run' } = {}) {
+    const { workItemsDisk } = this.modules;
+    const dir = this.productDir(slug);
+    const ids = [];
+    for (const row of PRACTICE_BACKDROP) {
+      const at = stampsFor(row, now);
+      const created = workItemsDisk.createWorkItem(
+        dir,
+        { title: row.title, kind: row.kind, priority: 5, labels: ['founder', label] },
+        { source: 'system', now: at.hers },
+      );
+      workItemsDisk.updateWorkItem(
+        dir, created.id,
+        { title: row.title, body: row.body, ...(row.state === 'scheduled' ? { runAt: now + (row.inMs ?? 0) } : {}) },
+        { source: 'founder', now: at.hers },
+      );
+      if (row.state !== 'scheduled') {
+        this.appendPracticeRun(slug, created.id, at.hers);
+        this.writePracticeTrace(slug, created.id, row.trace, at.hers + 1_000);
+      }
+      if (row.state === 'needs') {
+        workItemsDisk.updateWorkItem(
+          dir, created.id, { result: row.result },
+          { source: 'agent', now: at.hers + 1_000 + row.trace.length * 9_000 + 1_000 },
+        );
+      }
+      ids.push(created.id);
+    }
+    return { ids };
+  }
+
   /**
    * THE CLAIM AND THE RELEASE, so the row reads as one an agent worked on.
    *
@@ -840,9 +1051,23 @@ export class Store {
   // was for. Only when a line was really found: the sentence that says a folder
   // has no readme in it is a true answer and it is not a description, so it is
   // never written under the project's name.
-  finishFirstRunTask(slug, id) {
+  finishFirstRunTask(slug, id, round = 0) {
     const { workItemsDisk } = this.modules;
     const product = this.listProducts().find((p) => p.slug === slug) ?? null;
+    // A REPLY TO IT IS ANSWERED HERE TOO (2026-10-06). The first answer offers
+    // to make the summary shorter; any reply after that gets the shorter one,
+    // and no second trace, because the run it did is already on the thread.
+    // AND THE REPLY IS SETTLED FIRST, the way the supervisor settles one when a
+    // session exits: without it the row reads as an answer still waiting for an
+    // agent and stays in In progress (`answerSettled`, shared/answers.mjs).
+    if (product?.practice && round > 0) {
+      const before = this.readItem(slug, id);
+      this.settleAnswer(slug, id, before?.wrote?.answer?.ts ?? 0);
+      const item = workItemsDisk.updateWorkItem(
+        this.productDir(slug), id, { result: PRACTICE_REPLY_ANSWER }, { source: 'agent' },
+      );
+      return { item, line: PRACTICE_REPLY_ANSWER, oneLiner: null };
+    }
     // AND SINCE 2026-08-23 THE TASK IS SENT IN THE PRACTICE PROJECT, which
     // points at no folder at all. Everything below reads one, so it cannot run
     // here: a project that is not theirs has nothing honest to say about their
@@ -1231,6 +1456,13 @@ export class Store {
           if (file && !/work-items\.jsonl|dashboard\.jsonl|project\.json/.test(file)) return;
           this._notify();
         });
+        // fs.watch may return successfully, then emit an error (for example
+        // EMFILE). An unhandled error takes down the app, outside this catch.
+        // Reads still work without a watcher; release only the failed one.
+        watcher.on('error', () => {
+          try { watcher.close(); } catch {}
+          this.watchers = this.watchers.filter((w) => w !== watcher);
+        });
         this.watchers.push(watcher);
       } catch {}
     }