agentbox-app 0.1.7 → 0.1.11

package/renderer/dist/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Agentbox</title>
-    <script type="module" crossorigin src="./assets/index-B7hhfHrT.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-CwiDv5bL.css">
+    <script type="module" crossorigin src="./assets/index-D6qncgai.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-B-2Az952.css">
   </head>
   <body>
     <div id="root"></div>

package/scripts/memory-gate-hook.sh

@@ -0,0 +1,59 @@
+#!/bin/sh
+# ASK AGENTBOX WHETHER MEMORY ALLOWS THIS COMMAND, BEFORE IT RUNS (w-3958c3753d).
+#
+# Claude Code runs this as a PreToolUse hook on every Bash call of a worker
+# Agentbox started ("pre"), and again after it ("post"). The answer comes from
+# main/memory-gate-server.mjs over a local socket and is printed as it arrives:
+# nothing at all means "carry on as normal", and a deny is JSON Claude Code
+# reads. While the Mac is short of memory the answer simply arrives later.
+#
+# IT FAILS OPEN, FAST, ON PURPOSE. Measured on Claude Code 2.1.289: a hook that
+# times out, crashes or prints garbage lets the command run anyway, so there is
+# no strict fail-closed to be had. What this script promises instead is that it
+# never hangs an agent: no socket means run now; a socket nobody answers on
+# (the app crashed) is retried a few times in case another Agentbox takes over,
+# then run now; and every wait ends inside the hook's own time limit.
+#
+# curl and not nc: macOS nc quits before a slow answer arrives. curl ships on
+# every Mac, waits, and costs about 9 ms per check.
+
+mode="$1"
+sock="${AGENTBOX_GATE_SOCK:-}"
+[ -n "$sock" ] && [ -S "$sock" ] || exit 0
+
+input=$(cat)
+[ -n "$input" ] || input=null
+
+# Only what is safe to paste into JSON gets through from the environment.
+clean() { printf '%s' "$1" | tr -cd 'A-Za-z0-9._-'; }
+item=$(clean "${AGENTBOX_GATE_ITEM:-}")
+product=$(clean "${AGENTBOX_GATE_PRODUCT:-}")
+score="${AGENTBOX_GATE_SCORE:-0}"
+case "$score" in ''|*[!0-9]*) score=0 ;; esac
+
+body=$(printf '{"v":1,"event":"%s","item":"%s","product":"%s","score":%s,"ppid":%s,"hook":%s}' \
+  "$mode" "$item" "$product" "$score" "$PPID" "$input")
+
+if [ "$mode" != pre ]; then
+  printf '%s' "$body" | curl -s --unix-socket "$sock" --max-time 5 --data-binary @- "http://agentbox/$mode" >/dev/null 2>&1
+  exit 0
+fi
+
+# curl runs as a child we can stop: if Claude Code stops this hook while it
+# waits, curl goes with it, the connection closes, and the app forgets the
+# request instead of holding its place in line. curl prints the answer itself.
+pid=
+trap '[ -n "$pid" ] && kill "$pid" 2>/dev/null; exit 0' TERM INT HUP
+tries=0
+while :; do
+  printf '%s' "$body" | curl -s -f --unix-socket "$sock" --max-time "${AGENTBOX_GATE_MAX_S:-1700}" --data-binary @- http://agentbox/pre &
+  pid=$!
+  wait "$pid"
+  code=$?
+  pid=
+  [ "$code" -eq 0 ] && exit 0
+  tries=$((tries + 1))
+  [ "$tries" -ge 5 ] && exit 0
+  [ -S "$sock" ] || exit 0
+  sleep "${AGENTBOX_GATE_RETRY_S:-1}"
+done

package/shared/agent-import.mjs

@@ -106,16 +106,16 @@ export function agentsNeedingRows(chosen, existingItems = []) {
   return [...byName.values()];
 }
 
-/* ------------------------- AND THE THREADS SHE MEANT ----------------------- */
-// She was offered three things a picked thread could do and she picked the
-// plainest one. It does NOT resume the conversation, and that is the half these
-// words have to carry, because a row named after a conversation she had on
-// Friday is a row anybody would assume was carrying it on. So the body says, in
-// her vocabulary, that this starts fresh.
+/* --------------------------- AND THE THREADS ----------------------------- */
+// Of the three things a picked thread could do, this is the plainest one. It
+// does NOT resume the conversation, and that is the half these words have to
+// carry, because a row named after an earlier conversation is a row anybody
+// would assume was carrying it on. So the body says, in plain words, that this
+// starts fresh.
 //
 // Everything else is the agent import's shape, for the same reasons: one row per
-// thing she ticked, a label so a second press files nothing twice, and a
-// question so the supervisor waits for her rather than starting on its own.
+// thing the user ticked, a label so a second press files nothing twice, and a
+// question so the supervisor waits for the user rather than starting on its own.
 
 /** The label every imported thread carries. */
 export const THREAD_LABEL = 'thread-import';
@@ -128,9 +128,11 @@ export const threadLabel = (id) => `thread:${String(id ?? '').trim()}`;
 /**
  * WHEN SHE HAD IT, in the words a person uses about this week.
  *
- *  The window is seven days (`RECENT_DAYS`, main/agent-sessions.mjs), so a day
- *  name covers all of it and a date never has to appear. Anything the arithmetic
- *  cannot place says nothing rather than guessing. */
+ *  Inside a week a day name is the plain word. The window is ten days
+ *  (`RECENT_DAYS`, main/agent-sessions.mjs), and past a week a day name would
+ *  point at the wrong Monday, so those say the date. Anything the arithmetic
+ *  cannot place, or anything far outside the window, says nothing rather than
+ *  guessing. */
 export function whenWords(when, now = Date.now()) {
   const then = new Date(Number(when) || 0);
   if (!Number.isFinite(then.getTime()) || !when) return '';
@@ -139,6 +141,7 @@ export function whenWords(when, now = Date.now()) {
   if (days <= 0) return 'today';
   if (days === 1) return 'yesterday';
   if (days < 7) return `on ${then.toLocaleDateString('en-US', { weekday: 'long' })}`;
+  if (days < 14) return `on ${then.toLocaleDateString('en-US', { month: 'long', day: 'numeric' })}`;
   return '';
 }
 
@@ -151,10 +154,10 @@ export function startedIn(source) {
 /**
  * ONE IMPORTED THREAD'S WORDS.
  *
- *  The title is the thread's own, which is the first thing she typed into it, so
- *  the row in her inbox is called what she would call it. Ours is not added in
- *  front of it: a list of rows all opening with the same three words is a list
- *  she has to read past to find which is which.
+ *  The title is the thread's own, which is the first thing the user typed into
+ *  it, so the row in the inbox is called what they would call it. Ours is not
+ *  added in front of it: a list of rows all opening with the same three words is
+ *  a list that has to be read past to find which is which.
  *
  *  The last paragraph is the honest one. Agentbox read the top of the transcript
  *  to find this name and nothing else, and the reply starts a fresh session. A
@@ -207,6 +210,26 @@ export function threadsNeedingRows(chosen, existingItems = []) {
   return [...byId.values()];
 }
 
+/**
+ * WHICH CONVERSATIONS ARE ALREADY IN, so the card offers only the rest
+ *  (w-db6f5e331e). A Claude Code conversation is in once any row carries
+ *  `thread:<id>`; a Codex one once any row carries `codex:<id>`, except the
+ *  row that records a no, because the card is the way back to that one. Each
+ *  thread comes back as it was, with `imported: true` on the ones that are in. */
+export function markImported(threads = [], items = []) {
+  const inbox = new Set();
+  for (const item of items ?? []) {
+    const labels = item?.labels ?? [];
+    const declined = labels.includes('not-imported') && item?.status === 'done';
+    for (const label of labels) {
+      if (typeof label !== 'string') continue;
+      if (label.startsWith('thread:')) inbox.add(label.slice(7));
+      else if (label.startsWith('codex:') && !declined) inbox.add(label.slice(6));
+    }
+  }
+  return (threads ?? []).map((t) => (inbox.has(String(t?.id ?? '')) ? { ...t, imported: true } : t));
+}
+
 /**
  * WHICH AGENT A ROW IS ABOUT, or null for every other row in the inbox.
  *

package/shared/agents.d.mts

@@ -17,20 +17,20 @@ export interface AgentLike {
   // paragraphs that said what was done.
   lastSaid?: string;
   saidAt?: number;
-  // The session's own one-line title of itself, the last thing SHE typed into
+  // The session's own one-line title of itself, the last thing the user typed into
   // it, and the files it has had its hands on. Read off the transcript tail
   // that main/agents.mjs was already reading.
   about?: string;
   lastAsked?: string;
   touched?: string[];
-  // EVERY MESSAGE SHE TYPED into that session, oldest first. The first one is
+  // EVERY MESSAGE THE USER TYPED into that session, oldest first. The first one is
   // the ask and is what makes a five-day-old card recallable; the rest say
   // where the thread got to.
   asked?: { at: number; text: string }[];
   product?: string | null;
   productName?: string | null;
   startedByZero?: boolean;
-  // The moment SHE said she would come back to it, and when she said so.
+  // The moment the user said they would come back to it, and when they said so.
   // Set by the founder alone; main/agent-schedule.mjs keeps it.
   runAt?: number;
   runAtSetAt?: number;
@@ -56,15 +56,15 @@ export function howLong(ms: number): string;
 export function whereItRuns(agent: AgentLike): string;
 export function lastWord(agent: AgentLike, budget?: number): string;
 // The END of its last reply, which is where an agent puts its answer. `lastWord`
-// takes the front, which is right for her words and wrong for its own.
+// takes the front, which is right for the user's words and wrong for its own.
 export function howItEnded(raw: string | null | undefined, budget?: number): string;
 export function lastAsk(agent: AgentLike, budget?: number): string;
 export function whatItIs(agent: AgentLike): string;
 export function agentTitle(agent: AgentLike, now?: number): string;
 export function herWords(agent: AgentLike): { at: number; text: string }[];
 
-// One shape, hers, picked 2026-08-17: the message she started it with, up to
-// three later messages of hers, where it stopped, where it is working. There is
+// One shape: the message the user started it with, up to three later messages
+// of theirs, where it stopped, where it is working. There is
 // no setting and no second shape on purpose.
 export function agentRow(
   agent: AgentLike,
@@ -107,7 +107,7 @@ export interface AgentTurnLike {
   kind?: undefined;
 }
 
-// ONE THING THE AGENT RAN, between two messages. Shape B, hers.
+// ONE THING THE AGENT RAN, between two messages. Shape B.
 export interface AgentWorkLike {
   kind: 'work';
   at: number;
@@ -127,7 +127,7 @@ export type AgentEventLike = AgentTurnLike | AgentWorkLike;
 export const WORK_CHARS: number;
 export const WORK_RUN: number;
 export const WORK_TOTAL: number;
-// WHAT A TOOL CALL SAYS — the three rules her 2026-08-20 report split apart:
+// WHAT A TOOL CALL SAYS, in three rules:
 // the verb, the subject and the fold. Implemented in shared/work-lines.mjs and
 // re-exported from shared/agents.mjs so nothing needs a second import.
 export function workVerb(name: string): string;
@@ -139,6 +139,15 @@ export function workSubject(
 export function fullSubject(input: Record<string, unknown> | null | undefined): string;
 export function shortPath(raw: string, cwd?: string, home?: string): string;
 export function plainCommand(raw: string): string;
+// What a shell command did, in words, or null to leave it as the command. And
+// the steps that are the store's own records rather than the work, which are
+// not drawn at all.
+export function commandWork(
+  raw: string | null | undefined,
+  cwd?: string,
+  home?: string,
+): { verb: string; doing: string; subject: string } | null;
+export function isBookkeeping(name: string | null | undefined): boolean;
 export const RUN_MIN: number;
 export function groupWork<T extends { kind?: string }>(
   events: T[],
@@ -183,6 +192,15 @@ export function capRuns(
 export function saidCount(events: AgentEventLike[]): number;
 export const TRAIL_OPENING: number;
 export const TRAIL_TURNS: number;
+// TOOL-CALL SCAFFOLDING THAT LEAKED INTO THE PROSE, cut off the end of it.
+// item-thread.ts has read this since it was written and it was simply missing
+// from this file, which is why the screen's typecheck could not see it.
+//
+// A string in and a string out, which is every typed caller. The .mjs also
+// hands anything that is not a string straight back, for the untyped callers
+// that pass it whatever a stored field held; a declaration saying so would
+// have to lie about the string case, so the guard stays a runtime one.
+export function unleaked(text: string): string;
 export function conversationWindow(
   turns: AgentTurnLike[],
   bounds?: { opening?: number; keep?: number },