@schlessera/brain-ui-server 0.34.0 → 0.35.0

package/src/activity/recorder.ts

@@ -46,8 +46,21 @@ export interface TurnRecorder {
   readonly runId: string;
   observeFrame(msg: ServerMessage): void;
   observeActivity(event: BackendActivityEvent): void;
+  /** Record that this turn's principal was revoked while work kept running. */
+  recordPrincipalRevocation(principalId: string): void;
+  /** Record a live follow-up that joined this already-running turn. */
+  recordFollowUp(principalId: string): void;
+  /** Record who cancelled this turn or an interactive prompt within it. */
+  recordCancellation(principalId: string, kind?: "turn" | "ask_user"): void;
+  /** Record who answered an ask-user interaction. */
+  recordAskUserResponse(principalId: string): void;
   /** The user's approval decision arrived for a gated tool call. */
-  onApprovalDecision(toolUseId: string, allowed: boolean): void;
+  onApprovalDecision(
+    toolUseId: string,
+    decision: "allow" | "always_allow" | "deny",
+    requestKind: "tool" | "command",
+    principalId?: string
+  ): void;
   /**
    * Close the turn: merge the buffered result enrichment into the root's
    * single terminal write, cascade-cancel anything left open, roll up.
@@ -64,6 +77,8 @@ export function createTurnRecorder(
     profileId?: string;
     /** Billing classification of that profile, resolved at run start (U3). */
     billingMode?: BillingMode;
+    /** Principal that initiated this turn; absent means unattributed. */
+    principalId?: string;
   }
 ): TurnRecorder {
   const { store, onWrite, log } = deps;
@@ -76,6 +91,7 @@ export function createTurnRecorder(
   let resultOutcome: SpanOutcome | null = null;
   let resultUsage: SpanUsage | undefined;
   let resultAttrs: Record<string, unknown> | undefined;
+  let principalRevocationRecorded = false;
 
   const guard = (fn: () => void) => {
     try {
@@ -99,6 +115,7 @@ export function createTurnRecorder(
       kind: "turn",
       origin: "session",
       sessionId,
+      principalId: turn.principalId,
       // Profile + billing ride the ROOT span so the rollup can price the run
       // without any registry or env lookup of its own (a root missing the
       // billing attr falls back to env classification at rollup time).
@@ -253,9 +270,57 @@ export function createTurnRecorder(
       });
     },
 
-    onApprovalDecision(toolUseId, allowed) {
+    recordPrincipalRevocation(principalId) {
       guard(() => {
-        if (allowed) {
+        if (finished || principalRevocationRecorded) return;
+        ensureRoot();
+        store.appendEvent(rootSpanId, "principal_revoked", { principalId });
+        principalRevocationRecorded = true;
+        onWrite?.();
+      });
+    },
+
+    recordFollowUp(principalId) {
+      guard(() => {
+        if (finished) return;
+        ensureRoot();
+        store.appendEvent(rootSpanId, "follow_up", { principalId });
+        onWrite?.();
+      });
+    },
+
+    recordCancellation(principalId, kind = "turn") {
+      guard(() => {
+        if (finished) return;
+        ensureRoot();
+        store.appendEvent(rootSpanId, `${kind}_cancelled`, { principalId });
+        onWrite?.();
+      });
+    },
+
+    recordAskUserResponse(principalId) {
+      guard(() => {
+        if (finished) return;
+        ensureRoot();
+        store.appendEvent(rootSpanId, "ask_user_response", { principalId });
+        onWrite?.();
+      });
+    },
+
+    onApprovalDecision(toolUseId, decision, requestKind, principalId) {
+      guard(() => {
+        if (principalId) {
+          // One tool can raise several approval requests. The span-level actor
+          // remains the latest responder for compact views, while this
+          // append-only event preserves every decision and actor in order.
+          store.appendEvent(toolUseId, "approval_decision", {
+            principalId,
+            decision,
+            requestKind,
+          });
+          store.patchSpan(toolUseId, { principalId });
+        }
+        if (decision !== "deny") {
           // Everything before this moment was approval wait, not execution.
           store.patchSpan(toolUseId, { waitUntil: Date.now() });
         } else {

package/src/activity/runtime.ts

@@ -58,11 +58,8 @@ export function createActivityRuntime(
   const store = createActivityStore(db, deps.pricing ? { pricing: deps.pricing } : {});
   const stream = createActivityStream(store, log);
 
-  // The notifier is created BEFORE the boot sweep: its change cursor starts
-  // at the current head, so the terminal changes the sweep writes are above
-  // it and the first tick turns restart-interrupted runs into failure
-  // intents. Created after, the sweep's changes would sit below the cursor
-  // and a turn killed by a restart would never be notified.
+  // The notifier resumes its persisted cursor, including terminal changes
+  // committed while this server was down and interruptions from the boot sweep.
   const notifier = createActivityNotifier({
     db,
     store,

package/src/activity/sql.ts

@@ -0,0 +1,122 @@
+/** SQL owned by the activity store, kept together so the store reads as operations. */
+export const ACTIVITY_SQL = {
+  nextSeq: "SELECT COALESCE(MAX(seq), 0) AS hi FROM activity_changes WHERE run_id = ?",
+  insertChange:
+    "INSERT INTO activity_changes (run_id, seq, span_id, event_index) VALUES (?, ?, ?, ?)",
+  spanById: "SELECT * FROM activity_spans WHERE span_id = ?",
+  spanStateById: "SELECT run_id, outcome, attrs FROM activity_spans WHERE span_id = ?",
+  endSpan: `UPDATE activity_spans SET outcome = ?, outcome_reason = ?, ended_at = ?, attrs = ?,
+         input_tokens = COALESCE(?, input_tokens),
+         output_tokens = COALESCE(?, output_tokens),
+         cache_read_tokens = COALESCE(?, cache_read_tokens),
+         cache_creation_tokens = COALESCE(?, cache_creation_tokens),
+         cost_usd = COALESCE(?, cost_usd),
+         model = COALESCE(?, model)
+       WHERE span_id = ?`,
+  openSpansByRun:
+    "SELECT span_id FROM activity_spans WHERE run_id = ? AND outcome IS NULL ORDER BY started_at DESC",
+  spansByRun: "SELECT * FROM activity_spans WHERE run_id = ? ORDER BY started_at",
+  upsertRollup: `INSERT INTO activity_run_rollups
+         (run_id, origin, name, session_id, job_name, principal_id, principal_label,
+          principal_kind, started_at, ended_at, outcome,
+          duration_ms, span_count, input_tokens, output_tokens, cache_read_tokens,
+          cache_creation_tokens, cost_usd, effective_cost_usd, billing_mode,
+          pricing_estimate, failure_reason, detail_pruned)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+       ON CONFLICT(run_id) DO UPDATE SET
+         ended_at = excluded.ended_at, outcome = excluded.outcome,
+         duration_ms = excluded.duration_ms, span_count = excluded.span_count,
+         input_tokens = excluded.input_tokens, output_tokens = excluded.output_tokens,
+         cache_read_tokens = excluded.cache_read_tokens,
+         cache_creation_tokens = excluded.cache_creation_tokens,
+         cost_usd = COALESCE(activity_run_rollups.cost_usd, excluded.cost_usd),
+         effective_cost_usd = CASE
+           WHEN activity_run_rollups.effective_cost_usd IS NOT NULL
+             THEN activity_run_rollups.effective_cost_usd
+           WHEN activity_run_rollups.billing_mode IS NULL
+             OR activity_run_rollups.billing_mode = excluded.billing_mode
+             THEN excluded.effective_cost_usd
+           ELSE NULL
+         END,
+         billing_mode = COALESCE(activity_run_rollups.billing_mode, excluded.billing_mode),
+         pricing_estimate = CASE
+           WHEN activity_run_rollups.pricing_estimate IS NOT NULL
+             THEN activity_run_rollups.pricing_estimate
+           WHEN activity_run_rollups.billing_mode IS NULL
+             OR activity_run_rollups.billing_mode = excluded.billing_mode
+             THEN excluded.pricing_estimate
+           ELSE NULL
+         END,
+         failure_reason = excluded.failure_reason`,
+  insertSpan: `INSERT INTO activity_spans
+             (span_id, run_id, parent_span_id, name, kind, origin, session_id, job_name, principal_id,
+              attrs, started_at, writer, last_heartbeat_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  patchSpan: `UPDATE activity_spans SET principal_id = COALESCE(?, principal_id),
+             attrs = ?, wait_until = COALESCE(?, wait_until),
+             input_tokens = COALESCE(?, input_tokens),
+             output_tokens = COALESCE(?, output_tokens),
+             cache_read_tokens = COALESCE(?, cache_read_tokens),
+             cache_creation_tokens = COALESCE(?, cache_creation_tokens),
+             cost_usd = COALESCE(?, cost_usd),
+             model = COALESCE(?, model)
+           WHERE span_id = ?`,
+  spanRunById: "SELECT run_id FROM activity_spans WHERE span_id = ?",
+  nextEventIndex:
+    "SELECT COALESCE(MAX(event_index), -1) + 1 AS idx FROM activity_events WHERE span_id = ?",
+  insertEvent:
+    "INSERT INTO activity_events (span_id, event_index, ts, event_type, payload) VALUES (?, ?, ?, ?, ?)",
+  heartbeat:
+    "UPDATE activity_spans SET last_heartbeat_at = ? WHERE span_id = ? AND outcome IS NULL",
+  openSessionRuns:
+    "SELECT DISTINCT run_id FROM activity_spans WHERE outcome IS NULL AND origin = 'session'",
+  staleRoots: `SELECT span_id, run_id FROM activity_spans
+           WHERE outcome IS NULL AND parent_span_id IS NULL
+             AND writer != ? AND COALESCE(last_heartbeat_at, started_at) < ?`,
+  stuckRoots:
+    "SELECT * FROM activity_spans WHERE outcome IS NULL AND parent_span_id IS NULL AND started_at < ?",
+  spanChanges: `SELECT c.change_id, c.run_id, c.seq, s.*
+           FROM activity_changes c
+           JOIN activity_spans s ON s.span_id = c.span_id
+           WHERE c.change_id > ? AND c.event_index IS NULL
+           ORDER BY c.change_id LIMIT ?`,
+  eventChanges: `SELECT c.change_id, c.run_id, c.seq, e.*
+           FROM activity_changes c
+           JOIN activity_events e
+             ON e.span_id = c.span_id AND e.event_index = c.event_index
+           WHERE c.change_id > ? AND c.event_index IS NOT NULL
+           ORDER BY c.change_id LIMIT ?`,
+  terminalRootChanges: `SELECT MAX(c.change_id) AS change_id, s.*
+           FROM activity_changes c
+           JOIN activity_spans s ON s.span_id = c.span_id
+           WHERE c.change_id > ? AND c.event_index IS NULL
+             AND s.parent_span_id IS NULL AND s.outcome IS NOT NULL
+           GROUP BY s.span_id
+           ORDER BY change_id LIMIT ?`,
+  latestChangeCursor: "SELECT COALESCE(MAX(change_id), 0) AS hi FROM activity_changes",
+  eventsByRun: `SELECT e.* FROM activity_events e
+               JOIN activity_spans s ON s.span_id = e.span_id
+               WHERE s.run_id = ? ORDER BY e.ts, e.event_index`,
+  openRootSpans:
+    "SELECT * FROM activity_spans WHERE outcome IS NULL AND parent_span_id IS NULL ORDER BY started_at DESC",
+  pruneCandidates: `SELECT run_id, ended_at AS ended FROM activity_run_rollups r
+             WHERE detail_pruned = 0 AND ended_at IS NOT NULL
+               AND ((ended_at < ? AND ended_at < ?) OR ended_at < ?)
+               AND NOT EXISTS (
+                 SELECT 1 FROM activity_spans s
+                 WHERE s.run_id = r.run_id AND s.outcome IS NULL
+               )
+             LIMIT ?`,
+  markDetailPruned: "UPDATE activity_run_rollups SET detail_pruned = 1 WHERE run_id = ?",
+  markDigestCoverageGap:
+    "UPDATE activity_run_rollups SET failure_reason = COALESCE(failure_reason, 'digest coverage gap') WHERE run_id = ?",
+  deleteEventsByRun: `DELETE FROM activity_events WHERE span_id IN
+               (SELECT span_id FROM activity_spans WHERE run_id = ?)`,
+  deleteSpansByRun: "DELETE FROM activity_spans WHERE run_id = ?",
+  deleteChangesByRun: "DELETE FROM activity_changes WHERE run_id = ?",
+  compactChanges: `DELETE FROM activity_changes WHERE change_id < (
+             SELECT COALESCE(MAX(change_id), 0) FROM activity_changes
+           ) - 100000 AND run_id NOT IN (
+             SELECT DISTINCT run_id FROM activity_spans WHERE outcome IS NULL
+           )`,
+} as const;