agentbox-app 0.1.7 → 0.1.12

package/shared/team-rules.mjs

@@ -0,0 +1,230 @@
+// THE TEAM'S RULES ABOUT ROWS, IN ONE PLACE. Pure and browser-safe: the
+// supervisor asks them before it runs anything, and the window asks them
+// before it puts a row in somebody's inbox, so the two can never disagree about
+// whose a row is.
+//
+// A project is shared when its record carries a team id (main/team/projects.mjs).
+// Everything here leaves a private project exactly as it always was.
+import { pickFields } from './work-items.mjs';
+
+export const isShared = (product) => !!product?.team?.projectId;
+
+// THE PERSON WHOSE MAC RUNS AGENTS ON A ROW: whoever it was handed to, else
+// whoever started it, else (a row from before anyone signed in) whoever shared
+// the project.
+export function runnerOf(item, product) {
+  return item?.runner || item?.createdBy || product?.team?.sharedBy || null;
+}
+
+// A row a person has been given waits for that person, not for an agent.
+export const heldByAPerson = (item) => !!item?.assignee && item.assignee !== 'agent';
+
+// May a worker run on this row on this Mac, signed in as `me`?
+export function mayRunHere(item, product, me) {
+  if (!isShared(product)) return true;
+  if (!me) return false;
+  // A MESSAGE BETWEEN TWO PEOPLE NEVER RUNS AN AGENT, on either Mac. Turning
+  // one into work is @-mentioning an agent in the reply box, which starts a new
+  // thread of your own in the project the mention names; nothing a teammate
+  // writes into the shared record can start one here.
+  if (product?.team?.direct) return false;
+  if (heldByAPerson(item)) return false;
+  // ONLY YOU PUT YOUR MAC IN CHARGE OF A ROW. A runner naming you that somebody
+  // else's line wrote is a teammate trying to start an agent on your Mac with
+  // their words, so it does not count.
+  const runnerBy = item?.wrote?.runner?.by;
+  if (item?.runner === me && runnerBy && runnerBy !== me) return false;
+  // NOR DOES A TEAMMATE'S WORD START ONE. Lines pulled from teammates may not
+  // set these fields at all (whatATeammateMaySet below); this is the second
+  // wall, for a ledger that already holds such a line from before that rule.
+  // A field with no writer is from before anyone signed in, and is yours.
+  for (const field of STARTS_A_RUN) {
+    const by = item?.wrote?.[field]?.by;
+    if (by && by !== me) return false;
+  }
+  return runnerOf(item, product) === me;
+}
+const STARTS_A_RUN = ['body', 'answer', 'status', 'runAt'];
+
+// WHOSE INBOX A SHARED ROW IS IN: one person's at a time, whoever has to act.
+// A row given to a person is theirs until it is done; an agent's row is its
+// runner's. True leaves the row to the inbox's ordinary rules, which is what a
+// private row, or any row on a Mac nobody is signed in on, always gets.
+// WHO SPOKE LAST IN A CONVERSATION: the writer of its newest message.
+export function lastSpeaker(item) {
+  const a = item?.wrote?.answer;
+  const b = item?.wrote?.body;
+  const latest = a && (!b || (a.ts ?? 0) >= (b.ts ?? 0)) ? a : b;
+  return latest?.by ?? item?.createdBy ?? null;
+}
+
+/**
+ * WHAT IN A CONVERSATION IS WAITING ON YOU (w-920461cbe6). Asked the day
+ * threads shipped: in a busy chat, with three people answering your thread and
+ * others carrying on in the chat, what reaches your inbox? Not a row per
+ * message, and not a thread you are not in; and a thread waiting on you must
+ * not be lost because you said something in the chat.
+ *
+ * So: `chat` is how many messages in the main chat came after your own newest
+ * one there, and `threads` is every thread you are IN (you wrote the message it
+ * hangs off, or replied in it) where somebody else spoke after you, newest
+ * first, with how many replies are new, who wrote them, what the thread is
+ * about and its newest words. Null for a row with no record of who spoke where
+ * (one from before threads), which then reads by `lastSpeaker` as it always did.
+ */
+export function whatWaits(item, me) {
+  const talk = item?.talk;
+  if (!talk || !me) return null;
+  const since = (list) => { let n = 0; for (let k = list.length - 1; k >= 0 && list[k].by !== me; k -= 1) n += 1; return n; };
+  const threads = [];
+  for (const [uid, t] of Object.entries(talk.threads ?? {})) {
+    const replies = t.replies ?? [];
+    if (t.by !== me && !replies.some((r) => r.by === me)) continue;
+    const fresh = since(replies);
+    if (!fresh) continue;
+    const news = replies.slice(-fresh);
+    threads.push({
+      uid, mine: t.by === me, fresh,
+      people: [...new Set(news.map((r) => r.by))],
+      text: t.text, last: news[news.length - 1].text, lastBy: news[news.length - 1].by,
+      at: news[news.length - 1].ts,
+    });
+  }
+  threads.sort((a, b) => b.at - a.at);
+  return { chat: since(talk.chat ?? []), threads: threads.map(({ at, ...t }) => t) };
+}
+
+export function inMyInbox(item, product, me) {
+  if (!isShared(product) || !me) return true;
+  // A CONVERSATION NEEDS WHOEVER DID NOT SPEAK LAST (2026-10-01), so a message
+  // to three people is in all three inboxes until one of them answers, and the
+  // answer puts it back in everyone else's. One person to one works the same.
+  // WITH THREADS (w-920461cbe6) the same rule is read per place: the chat, and
+  // each thread you are in. One row, whichever of them is waiting.
+  if (product?.team?.direct) {
+    if (item.status === 'done') return false;
+    const waits = whatWaits(item, me);
+    if (waits) return waits.chat > 0 || waits.threads.length > 0;
+    const by = lastSpeaker(item);
+    return by ? by !== me : item.assignee === me;
+  }
+  if (heldByAPerson(item)) return item.assignee === me && item.status !== 'done';
+  return runnerOf(item, product) === me;
+}
+
+// A CONVERSATION WHERE YOU SPOKE LAST IS DONE FOR YOU (w-57a202a968), until
+// the other person writes again and `inMyInbox` brings it back. Without it a
+// message you answered was on no tab and no column: out of your inbox by the
+// rule above, never In progress, and not Done because its status is not done.
+// Her words: "It's not supposed to leave the board; it's supposed to go in Done."
+export function iSpokeLast(item, product, me) {
+  if (!me || !product?.team?.direct || item?.status === 'done') return false;
+  // Done for you means nothing in it waits on you: the chat or any thread.
+  const waits = whatWaits(item, me);
+  if (waits) return waits.chat === 0 && waits.threads.length === 0;
+  return lastSpeaker(item) === me;
+}
+
+// A REPLY HANDS A PERSON-TO-PERSON ROW TO THE OTHER PERSON, so a conversation
+// goes back and forth between two inboxes instead of sitting in both. Returns
+// who it goes to, or null when a reply changes nothing about whose it is.
+export function handedOnByReply(item, product, me) {
+  if (!isShared(product) || !me || !heldByAPerson(item) || item.assignee !== me) return null;
+  const people = Array.isArray(item.people) ? item.people : [];
+  return people.find((p) => p !== me) || (item.createdBy && item.createdBy !== me ? item.createdBy : null);
+}
+
+// WHAT A TEAMMATE'S LINE MAY SET ON THIS MAC. Found by review 2026-10-01: a
+// teammate's line with source "founder" could set the body, the answer, the
+// status, the schedule or the model of any row in a shared project, including
+// a row whose runner is you, and the supervisor then started an agent here on
+// their words. So a pulled line keeps only the summary (which the board shows
+// anyway), who has to act next, and, in a message between two people (which
+// never runs an agent), the message itself. Everything else is dropped before
+// it reaches the disk, claims and epochs included. Returns null when nothing
+// is left.
+const A_TEAMMATE_MAY_SET = ['problem', 'progress', 'solution', 'blockedBy', 'blocks', 'assignee'];
+// The status rides too: a new message reopens a conversation put away, and a
+// message record never starts an agent (mayRunHere).
+//
+// AND A REACTION, which is the chips under a message (w-560647d4db). It is on
+// this list rather than the one above because it is only ever drawn in a
+// conversation, and because an unrecognised delta on an ordinary shared task
+// would be a teammate writing a field nothing there reads. It cannot start an
+// agent: `STARTS_A_RUN` above names the four fields that can, and a reaction
+// touches none of them, so a chip never puts the row in anybody's inbox.
+//
+// AND WHICH MESSAGE A REPLY ANSWERS (w-920461cbe6), for the same two reasons:
+// only a conversation draws a thread, and the mark rides beside an `answer`
+// this list already lets through. Without it a teammate's thread reply would
+// land in the middle of your chat instead of in the thread.
+const IN_A_MESSAGE_ALSO = ['title', 'body', 'answer', 'people', 'status', 'react', 'inReplyTo'];
+// AND THE LEVEL THE SENDER PICKED, ON THE OPENING LINE ALONE (w-7ba439c883).
+// A message now carries how urgent its sender thought it was, and that number
+// decides where it sits in the inbox it lands in, so it has to survive the
+// pull. It may not become a way to re-rank a row afterwards, though: the level
+// rides the line that MAKES the row and no other.
+//
+// `kind` is how that line is known. Only a row's first line sets it, and a
+// teammate may not set it here at all, so it is a marker rather than a field:
+// it is read, then dropped with everything else that is not allowed.
+//
+// WHAT THIS DOES NOT STOP, said plainly: a teammate who forges a line carrying
+// a kind can still re-rank the one conversation the two of you share. They can
+// already rewrite that row's title, body, answer and status (above), so this
+// opens no row that was closed to them, and nothing outside a conversation is
+// reachable either way.
+const WHEN_A_MESSAGE_OPENS = ['priority'];
+const opensARow = (patch) => 'kind' in patch;
+export function whatATeammateMaySet(line, { direct = false } = {}) {
+  if (!line || typeof line !== 'object' || !line.patch || typeof line.patch !== 'object') return null;
+  const allowed = direct
+    ? [...A_TEAMMATE_MAY_SET, ...IN_A_MESSAGE_ALSO, ...(opensARow(line.patch) ? WHEN_A_MESSAGE_OPENS : [])]
+    : A_TEAMMATE_MAY_SET;
+  const kept = {};
+  for (const field of allowed) if (field in line.patch) kept[field] = line.patch[field];
+  const patch = pickFields(kept);
+  if (!patch) return null;
+  return { id: line.id, ts: line.ts, source: line.source, by: line.by, uid: line.uid, patch };
+}
+
+// A LEASE BELONGS TO THE MAC THAT TOOK IT. A claim, an epoch, a release or a
+// heartbeat is a worker's hold on one Mac, so it never rides a line across to
+// another one — not even to a second copy of the app that is also yours.
+export function withoutALease(line) {
+  const out = { ...line };
+  delete out.claim; delete out.epoch; delete out.release; delete out.heartbeat;
+  return out;
+}
+
+// A LINE AS IT COMES BACK FROM THE CLOUD, the same on both backends. Who wrote
+// it and when are the database's (by_person, created_at), never the copy in
+// the body, and a teammate's line carries no lease (above).
+export function asPulled(body, { by, at, me }) {
+  const line = { ...body, by };
+  if (by === me) return line;
+  const kept = withoutALease(line);
+  if (Number.isFinite(at)) kept.ts = at;
+  return kept;
+}
+
+// YOUR OWN LINE, COMING BACK FROM A SECOND COPY OF THE APP SIGNED IN AS YOU.
+//
+// Reported 2026-10-04 (w-2fce569057): a message sent to a teammate never came
+// back. It had been sent from a second copy. It reached the cloud and it
+// reached the teammate's app; what it never reached was the everyday copy,
+// because the pull skipped every line whose writer was you, on the reasoning
+// that a line you wrote is already here. True of the copy that wrote it, false
+// of every other copy you own, and a conversation missing your own half reads
+// as a message that never sent.
+//
+// ONLY IN A MESSAGE RECORD, where no agent ever runs (mayRunHere). On an
+// ordinary shared row your own answer, body or status is exactly what starts
+// one, and `mayRunHere` believes a line whose writer is you, because it is you:
+// carrying those across would start a second agent on the same row on your
+// other Mac. So nothing crosses there, and your own words stay where you typed
+// them. Returns null when the line is not yours to bring back.
+export function whatYourOtherCopyMaySet(line, { direct = false } = {}) {
+  if (!direct || !line || typeof line !== 'object') return null;
+  return withoutALease(line);
+}

package/shared/team-status.d.mts

@@ -0,0 +1,11 @@
+export interface PersonStatus { text: string; until: number | null }
+export type HoldId = 'today' | 'tomorrow' | 'week' | 'open';
+
+export const STATUS_MAX: number;
+export const HOLDS: { id: HoldId; label: string }[];
+
+export function cleanStatus(text: unknown): string | null;
+export function liveStatus(status: PersonStatus | null | undefined, now?: number): PersonStatus | null;
+export function hasLapsed(status: PersonStatus | null | undefined, now?: number): boolean;
+export function holdsUntil(until: number | null | undefined, now?: number): string;
+export function holdEnds(id: HoldId | string, now?: number): number | null;

package/shared/team-status.mjs

@@ -0,0 +1,90 @@
+// A STATUS LINE YOU WRITE YOURSELF: the rules, in one place.
+//
+// Four of six people interviewed asked for the same thing, and the founder
+// put it plainest: "If I'm going to spend a day or a few days in meetings, I
+// don't want the board to make it seem like I'm not doing any work." So a
+// person carries one short line they wrote, and it holds until a time they
+// chose.
+//
+// THE EXPIRY IS READ, NOT SWEPT. An expired line is nothing to everyone who
+// reads it, at the moment it expires, without anyone's Mac having to be awake
+// to clear it. The owner's Mac also clears it in the cloud on the next sync
+// after it lapses, so the text does not sit there for good; that is tidying,
+// not what makes it disappear.
+
+/** A line is one line. Longer than this is a note, and the places it is drawn
+ *  (a sidebar row, a hover card) cannot hold one. */
+export const STATUS_MAX = 80;
+
+/** What the app stores from what somebody typed: trimmed, cut to one line and
+ *  to STATUS_MAX, or null when they said nothing. */
+export function cleanStatus(text) {
+  const one = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return one ? one.slice(0, STATUS_MAX) : null;
+}
+
+/** The status as it reads NOW: null when there is no text, or when the time
+ *  they chose has passed. Everything that draws a status goes through here. */
+export function liveStatus(status, now = Date.now()) {
+  const text = cleanStatus(status?.text);
+  if (!text) return null;
+  const until = status?.until ?? null;
+  if (until && until <= now) return null;
+  return { text, until };
+}
+
+/** True when there is text in the cloud that no longer reads, which is the
+ *  owner's Mac's cue to clear it. */
+export function hasLapsed(status, now = Date.now()) {
+  return !!cleanStatus(status?.text) && !!status?.until && status.until <= now;
+}
+
+/** How long it holds, in words, for the end of a line: "until 6pm today",
+ *  "until Monday", "until Mar 3". Empty when it holds until they clear it. */
+export function holdsUntil(until, now = Date.now()) {
+  if (!until || until <= now) return '';
+  const d = new Date(until);
+  if (new Date(now).toDateString() === d.toDateString()) {
+    const h = d.getHours();
+    const mins = d.getMinutes() ? `:${String(d.getMinutes()).padStart(2, '0')}` : '';
+    return `until ${h % 12 === 0 ? 12 : h % 12}${mins}${h < 12 ? 'am' : 'pm'} today`;
+  }
+  // Inside a week a weekday names itself. Eight days out, "until Monday"
+  // would be the Monday after the one they meant, so the date is safer.
+  if (until - now < 7 * 86_400_000) return `until ${d.toLocaleDateString(undefined, { weekday: 'long' })}`;
+  return `until ${d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })}`;
+}
+
+/** The four holds the app offers, in the order they are drawn. */
+export const HOLDS = [
+  { id: 'today', label: 'Today' },
+  { id: 'tomorrow', label: 'Tomorrow' },
+  { id: 'week', label: 'This week' },
+  { id: 'open', label: 'Until I clear it' },
+];
+
+/** When a status set now runs out. A moment they chose wins while it is still
+ *  ahead ("they should be able to choose their own timelines", 2026-10-04);
+ *  anything else, now, the past or not a number at all, falls back to the
+ *  named hold, so a stale or garbled moment can never end a status at once. */
+export function statusEnds({ hold = 'open', until } = {}, now = Date.now()) {
+  if (typeof until === 'number' && Number.isFinite(until) && until > now) return until;
+  return holdEnds(hold, now);
+}
+
+/** When a hold runs out. Today and tomorrow end at the end of that day, so a
+ *  line set at 9am and one set at 4pm both last the day out. */
+export function holdEnds(id, now = Date.now()) {
+  if (id === 'open') return null;
+  const d = new Date(now);
+  d.setHours(23, 59, 59, 999);
+  if (id === 'tomorrow') d.setDate(d.getDate() + 1);
+  // THE PARENTHESES ARE LOAD BEARING. Written as `d.getDate() + (7 - day) % 7
+  // || 7`, `+` binds tighter than `||`, so on a Sunday it read
+  // `(11 + 0) || 7` and set the date to today: "this week" ended tonight.
+  if (id === 'week') {
+    const toSunday = (7 - d.getDay()) % 7;
+    d.setDate(d.getDate() + (toSunday || 7));
+  }
+  return d.getTime();
+}

package/shared/terminal-links.d.mts

@@ -0,0 +1,2 @@
+export type TerminalLink = { url: string; range: { start: { x: number; y: number }; end: { x: number; y: number } } };
+export function linksAtRow(at: (y: number) => { text: string; wrapped: boolean } | undefined, row: number): TerminalLink[];

package/shared/terminal-links.mjs

@@ -0,0 +1,55 @@
+// THE WEB ADDRESSES ON ONE ROW OF THE APP'S TERMINAL, for xterm's link provider
+// (renderer/src/components/TaskTerminal.tsx), which opens them in the browser.
+//
+// The terminal had none, so `claude auth login`'s "If the browser didn't open,
+// visit: https://..." was text you could not click (2026-10-05). That address
+// is about 600 characters and wraps over many rows, so the search runs over the
+// whole LOGICAL line, every row joined to the ones it wraps onto, and a link is
+// handed back for any row it touches, with its range spanning all of them.
+//
+// IT LIVES IN `shared` SO IT CAN BE TESTED without a DOM: xterm's buffer is
+// read through `at(y)`, which answers `{ text, wrapped }` for a 0-based row,
+// `wrapped` being xterm's `isWrapped` (this row continues the one above).
+// Ranges come back the way xterm takes them, 1-based and inclusive. One
+// character is one cell, which holds for anything an address can contain.
+
+// The scheme, at least one character after it, and none of the characters that
+// end an address in prose.
+const ADDRESS = /https?:\/\/[^\s"'<>`]+/g;
+// Punctuation that closes the sentence around an address, not the address.
+const TRAILING = /[.,;:!?)\]}'"]+$/;
+
+/**
+ * @param {(y: number) => ({ text: string, wrapped: boolean } | undefined)} at
+ * @param {number} row 0-based
+ * @returns {{ url: string, range: { start: { x: number, y: number }, end: { x: number, y: number } } }[]}
+ */
+export function linksAtRow(at, row) {
+  if (!at(row)) return [];
+  let top = row;
+  while (top > 0 && at(top)?.wrapped && at(top - 1)) top -= 1;
+  const rows = [at(top).text];
+  for (let y = top + 1; at(y)?.wrapped; y += 1) rows.push(at(y).text);
+
+  // Where each row starts in the joined string, to turn an index back into a
+  // cell.
+  const starts = [];
+  let joined = '';
+  for (const text of rows) { starts.push(joined.length); joined += text; }
+  const cell = (i) => {
+    let r = starts.length - 1;
+    while (r > 0 && starts[r] > i) r -= 1;
+    return { x: i - starts[r] + 1, y: top + r + 1 };
+  };
+
+  const out = [];
+  for (const m of joined.matchAll(ADDRESS)) {
+    const url = m[0].replace(TRAILING, '');
+    if (!/^https?:\/\/./.test(url)) continue;
+    const start = cell(m.index);
+    const end = cell(m.index + url.length - 1);
+    if (start.y > row + 1 || end.y < row + 1) continue;
+    out.push({ url, range: { start, end } });
+  }
+  return out;
+}

package/shared/terminal-state.d.mts

@@ -1 +1,2 @@
 export function commandRunning(processName: string, exited: boolean): boolean;
+export function whenACommandFinishes(onFinish: () => void): (processName: string, exited: boolean) => void;

package/shared/terminal-state.mjs

@@ -56,3 +56,19 @@ export function commandRunning(processName, exited) {
   if (!name) return false;
   return !SHELLS.test(shellName(name));
 }
+
+// A COMMAND HAS JUST FINISHED: the terminal went from running something back to
+// its prompt, or the shell ended under it. Settings' Add account panel reloads
+// the accounts on this, because "the account appears above when it is done"
+// was a promise nothing kept: the row read "Not signed in" after `claude auth
+// login` said "Login successful." (2026-10-05). Feed it every reading the
+// terminal polls; it calls `onFinish` once per command, and never for a shell
+// that has only ever sat at its prompt.
+export function whenACommandFinishes(onFinish) {
+  let running = false;
+  return (processName, exited) => {
+    const now = commandRunning(processName, exited);
+    if (running && !now) onFinish();
+    running = now;
+  };
+}

package/shared/thread-cards.d.mts

@@ -0,0 +1,19 @@
+// Types for shared/thread-cards.mjs, for the window side.
+import type { ThreadStateWord, WorkItem } from '../renderer/src/types';
+
+export const THREAD_STATES: ThreadStateWord[];
+export function threadState(item: Partial<WorkItem> & { claimExpired?: boolean }, now?: number): ThreadStateWord;
+export function firstSentence(text: string | undefined | null, max?: number): string;
+export const SUMMARY_WORDS: number;
+export function wordsIn(text: string | undefined | null): number;
+export const CONTEXT_WORDS: number;
+export const DONE_STEPS: number;
+export const DONE_STEP_WORDS: number;
+export function doneSteps(progress: string | undefined | null): string[];
+export function summaryOf(item: Partial<WorkItem>): { problem: string; progress: string; solution: string; written: boolean };
+export function cardsFor(p: { products: unknown[]; readItems: (product: any) => any[]; now?: number; since?: number | null }): any[];
+type ProjectSeen = { personal?: boolean; seenBy?: string; seenByPeople?: string[] } | null | undefined;
+export function shownToTeam(item: Partial<WorkItem>, since?: number | null, product?: ProjectSeen): boolean;
+export function visibilityOf(item: Partial<WorkItem>, product?: ProjectSeen): 'team' | 'people' | 'private' | undefined;
+export function projectSeenBy(product: ProjectSeen): { who: 'private' | 'team' | 'people'; people: string[] };
+export function shownToPeople(item: Partial<WorkItem>, product?: ProjectSeen): string[];