synabun 2.0.0 → 2.0.7

package/neural-interface/lib/assistant-runtime.js

@@ -8,21 +8,24 @@
 // rehydration, per-turn auto-recall, dispatch mailbox delivery, and the memory
 // obligation nudges. All server dependencies are injected.
 
-import { randomUUID } from 'node:crypto';
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { createClaudeBrain } from './assistant-brains/claude.js';
 import { createCodexBrain } from './assistant-brains/codex.js';
 import { createOpenCodeBrain } from './assistant-brains/opencode.js';
 import { buildAssistantPersona, formatMailbox, reconcileRouteItems } from './assistant-persona.js';
-import { codexUsageCostUsd } from './assistant-budget.js';
+import { normalizeTestDensity, testDensityStamp } from './assistant-test-density.js';
+import { codexUsageCostUsd, floorCents } from './assistant-budget.js';
+import { MIN_SPEND_USD } from './assistant-budget-split.js';
 import { CLAUDE_ESTIMATE_SOURCE, createClaudeMeter, createCodexMeter, createOpenCodeMeter, totalTokens, withTotal, zeroTokens } from './assistant-usage.js';
 import { claudeTokensCostUsd } from './assistant-pricing.js';
 import { normalizeRouteMode } from './assistant-config.js';
 import { TASK_CLASS_META } from './assistant-router.js';
+import { chooseUsageAccount } from './account-usage.js';
 import { defaultIsHidden, enabledStandIn, findModel, providerAllHidden, selectSheetModels } from './assistant-catalog.js';
 import { normalizeEffort } from './effort-levels.js';
-import { claudeRouteAvailability, createRouteGate, mcpStatusRouteAvailability, ROUTE_GATE_LOOP_MESSAGE } from './assistant-route-gate.js';
+import { claudeRouteAvailability, createRouteGate, isReplyTool, mcpStatusRouteAvailability, ROUTE_GATE_LOOP_MESSAGE } from './assistant-route-gate.js';
 import { claudeReadOnlyPermission, planDenyMessage, planToolDecision, readOnlyDenyMessage, readOnlyToolDecision } from './assistant-plan-permissions.js';
 import { codexRouteGateBootstrap } from './assistant-route-gate-codex.js';
 import { proposedPlanText } from './assistant-envelope.js';
@@ -36,17 +39,49 @@ export const DEFAULT_SESSION_TITLE = 'SynaBun';
 export function isDefaultSessionTitle(title) { return !title || /^(?:SynaBun|Assistant(?: \d+)?)$/.test(String(title).trim()); }
 const MAILBOX_REASONS = new Set(['turn_completed', 'needs_input', 'permission_request', 'failed', 'interrupted', 'stalled', 'budget_warning', 'budget_exceeded', 'budget_unpriced', 'queue_started', 'user_intervened', 'stopped']);
 // A stopped run reaches the brain when the user stopped it or it ran out of money.
-const MAILBOX_STOP_REASONS = new Set(['user', 'budget_cap', 'session_budget_cap', 'budget_unpriced']);
+const MAILBOX_STOP_REASONS = new Set(['user', 'budget_cap', 'session_budget_cap', 'budget_unpriced', 'budget_share']);
+/** The `[SynaBun Budget]` line: a change of the session budget reaches the brain as one line before its next turn. */
+export const BUDGET_HEADER = '[SynaBun Budget]';
+/**
+ * What the brain is told when the budget changed after its prompt was built (setting: { unlimited,
+ * amountUsd }; money: the session's budget view, for what is spent and left). The key changes only
+ * with the setting, so spending never repeats the line.
+ */
+export function budgetStamp(setting, money = null) {
+  if (!setting) return { key: null, text: '' };
+  const usdText = (value) => `$${(Number(value) || 0).toFixed(2)}`;
+  if (setting.unlimited === true) {
+    return { key: 'unlimited', text: `${BUDGET_HEADER} The user switched this session to No limit: there is no budget now, no provider shares and no stops for spend. Do not pass budget_usd; tasks route by the saved routes as before. Spend is still metered (agent_usage).` };
+  }
+  const amount = Number(setting.amountUsd) || 0;
+  const spent = money && Number.isFinite(Number(money.totalUsd)) ? Number(money.totalUsd) : null;
+  const status = spent === null ? '' : ` ${usdText(spent)} spent, ${usdText(Math.max(0, amount - spent))} left.`;
+  return {
+    key: `limited:${amount.toFixed(2)}`,
+    text: `${BUDGET_HEADER} The user set this session's budget to ${usdText(amount)} (your own turns plus every run, at list price; one warning at 80%).${status} SynaBun divides what is left across the providers: each provider's runs draw from its share and your turns from your provider's share (agent_usage shows the split). When a share is used up, agent_route moves a task to a provider with money left, so saved routes yield to the budget. budget_usd is optional: a ceiling for one run inside its share.`,
+  };
+}
 const usd = (value) => `$${(Number(value) || 0).toFixed(2)}`;
 const TRANSCRIPT_EVENT_TYPES = new Set(['assistant', 'user', 'result', 'system']);
 // Below the autonomous level a remote session's brain asks before any tool the
 // read-only classifier would refuse. These stay unasked: questions and plans (they reach
 // the user anyway), in-session bookkeeping, subagent launches (their own calls
-// are asked), memory writes, and agent_dispatch (its route card is the approval).
-const REMOTE_ASK_EXEMPT = new Set([
+// are asked), memory writes, agent_dispatch (its route card is the approval), and
+// whatsapp_send_file: delivering a file the user asked for is a reply, like the final text
+// (any host's name for it: isReplyTool).
+export const REMOTE_ASK_EXEMPT = new Set([
   'AskUserQuestion', 'ExitPlanMode', 'EnterPlanMode', 'TodoWrite', 'TodoRead', 'ToolSearch', 'Task', 'Agent',
   'mcp__SynaBun__remember', 'mcp__SynaBun__reflect', 'mcp__SynaBun__category', 'mcp__SynaBun__agent_dispatch',
+  'mcp__SynaBun__whatsapp_send_file',
 ]);
+/**
+ * The credential of one brain launch of a WhatsApp conversation (whatsapp_send_file): it reaches
+ * that brain's SynaBun MCP server only (Claude: an MCP header; Codex and OpenCode: the MCP child's
+ * environment), which sends it on POST /api/assistant/whatsapp/send-file and nowhere else. Random,
+ * in memory only (never on the record, in a log, the persona or a transcript), gone with the brain.
+ */
+export const BRAIN_CREDENTIAL_RE = /^sbb_[A-Za-z0-9_-]{43}$/;
+export function mintBrainCredential() { return `sbb_${randomBytes(32).toString('base64url')}`; }
 // An OpenCode brain of a remote session reaches the web through these on its own
 // (no SynaBun browser, no approval): the gate plugin refuses them.
 const REMOTE_OPENCODE_WEB_TOOLS = new Set(['webfetch', 'websearch', 'codesearch']);
@@ -155,6 +190,9 @@ export function mergeHooks(a, b) {
 export function createAssistantRuntime({
   dispatcher = null,
   claudeAccounts = null,
+  // lib/codex-accounts.js: a Codex brain whose account cannot run is refused before it starts.
+  codexAccounts = null,
+  accountUsage = null,
   ClaudeSession = null,
   sdkVersion = null,
   handleCodexSkinWebSocket = null,
@@ -183,8 +221,11 @@ export function createAssistantRuntime({
   codexBin = () => 'codex',
   codexGateBootstrap = codexRouteGateBootstrap,
   // Codex list prices (assistant-budget.js createModelPricing). When given, a
-  // brain whose spend cannot be priced is refused (the caps fail closed).
+  // brain whose spend cannot be priced is refused under a budget (it fails closed).
   pricing = null,
+  // The session budget (assistant-budget-planner.js): the setting, the provider shares, the
+  // checkpoints. Defaults to the dispatcher's own planner.
+  budget: budgetPlanner = null,
   usage = null,
   // The meters of assistant-usage.js, by provider (tests swap one in).
   meterFactories = null,
@@ -192,6 +233,11 @@ export function createAssistantRuntime({
   // Clarification (assistant-clarify.js): human prompts, the brain's own
   // question cards and the clarify cards' answers reach it from here.
   clarifier = null,
+  // The user-context engine (assistant-user-context.js): what the Assistant knows about the
+  // user, nudges from recent conversations, the learning loop and the per-turn trace.
+  userContext = null,
+  // lib/greeting/ engine (or null): the note about the greeting a conversation opened with, and when the person was last here.
+  greeting = null,
   // Remote sessions (lib/remote-policy.js): the level registry shared with the
   // dispatcher and the WhatsApp bridge, and the registered project paths a
   // remote session's workers must run in.
@@ -214,7 +260,6 @@ export function createAssistantRuntime({
     retention: 200,
     defaultBrain: config.defaultBrain || {},
     personaExtra: config.persona?.extra || '',
-    maxBudgetUsd: Number(config.brains?.claude?.maxBudgetUsd) || 10,
     // A brain's approval or question card waits this long, then it is declined
     // (0 = wait forever). A pending card holds the turn and the mailbox.
     approvalTimeoutMs: Math.max(0, Number(config.approvalTimeoutMinutes ?? 10) * 60_000) || 0,
@@ -295,7 +340,9 @@ export function createAssistantRuntime({
     return {
       record, brain: null, brainProvider: null, brainMeter: null, brainMeterProvider: null, turnTaskId: null, turnTasks: [], sockets: new Set(), buffer: [], running: false, pendingControls: new Map(), controlTimers: new Map(),
       mailbox: [], mailboxTimer: null, obligations: new Set(), rememberedThisTurn: false, disposeTimer: null, personaText: '',
-      lastPrompt: '', mailboxTurn: false, nudgedRuns: new Set(),
+      // The last human prompt and where it came from ('ui', 'whatsapp', 'api'): a route continuation
+      // answers there (lastPromptOrigin; the transcript's after a restart).
+      lastPrompt: '', lastPromptOrigin: null, mailboxTurn: false, nudgedRuns: new Set(),
       // The provider's usage limit as last reported (limitNotice), or null: one state, never a list.
       limit: null,
       // Human prompts so far: one request cycle each (assistant-clarify.js briefs).
@@ -303,6 +350,8 @@ export function createAssistantRuntime({
       // Claude brains: the turns sent, keyed by their final text, for the in-process recall hook.
       turnMeta: new Map(),
       desktopGrant: null,
+      // A WhatsApp conversation's brain credential (mintBrainCredential): this launch only, never persisted.
+      brainCredential: null,
       // Route gate (assistant-route-gate.js): one per session while routing is wired.
       // gatePluginAt: when the OpenCode serve loaded the gate plugin (until then, reactive).
       // gateNudge: { reason, gen } while a reactive refusal waits for its turn to end.
@@ -340,6 +389,10 @@ export function createAssistantRuntime({
       // Closing (endSessionWork): the close under way (a promise), and the generation it started.
       gen: 0, work: new Map(), workActive: null, workTimer: null, workPumpQueued: false, routeGens: new Map(),
       closing: null, closedGen: 0,
+      // User context (assistant-user-context.js): what the live brain was built for (a layer
+      // switched since restarts an idle brain), the human turns sent and not ended yet (oldest
+      // first), and the last reply (context for what the next message teaches).
+      brainUserContext: null, ucTurns: [], lastReply: '',
     };
   }
   // ── remote sessions (lib/remote-policy.js) ─────────────────────────────────
@@ -727,6 +780,12 @@ export function createAssistantRuntime({
    */
   function brainNeedsRestart(live) {
     if (!live?.brain) return false;
+    // Its persona was built with (or without) a user-context layer that was switched since.
+    if (userContext && live.brainUserContext !== null) {
+      let key = null;
+      try { key = userContext.brainKey(live.record); } catch { key = null; }
+      if (key !== null && key !== live.brainUserContext) return true;
+    }
     const policy = remotePolicyFor(live);
     // A Codex / OpenCode brain built before the session became remote is not read-only yet.
     if (live.brainProvider !== 'claude-code') return !!policy && live.brainRemoteReadOnly !== true;
@@ -747,6 +806,8 @@ export function createAssistantRuntime({
     const effectiveMode = policy ? clampRouteMode(policy, mode || defaultRouteMode(), { now: now() }) : (mode || defaultRouteMode());
     return { mode, effectiveMode, defaultMode: defaultRouteMode(), askBelow };
   }
+  /** The session's Test density: its own value, else the default level (assistant-test-density.js). */
+  function testDensityOf(record) { return normalizeTestDensity(record?.testDensity); }
   function computerSupported() { try { return !!desktop?.isSupported?.(); } catch { return false; } }
   /**
    * Effective computer toggle: explicit per-session value, else the service default (ON after setup).
@@ -825,6 +886,8 @@ export function createAssistantRuntime({
   function publicRecord(record, { withLive = true, live = null, persisted = false } = {}) {
     const out = { ...record };
     if (!persisted) delete out.usageState;
+    // The user-context state (frozen digest, delivery ledgers) is the server's own.
+    if (!persisted) delete out.userContext;
     if (withLive && live) {
       out.running = live.running;
       out.attached = live.sockets.size;
@@ -840,7 +903,10 @@ export function createAssistantRuntime({
       // A remote session's computer use is not a per-conversation choice: no explicit value, and why it is what it is.
       out.computerUseExplicit = policy ? null : (record.computerUse === true || record.computerUse === false ? record.computerUse : null);
       out.computerRemote = computer ? { state: computer.state, reason: computer.reason, level: computer.level, approved: live.computerTurn?.approved === true } : null;
-      out.features = { routing: !!router, computer: computerSupported() };
+      out.testDensity = testDensityOf(record);
+      out.testDensityExplicit = normalizeTestDensity(record.testDensity, null);
+      // `rename`: this server keeps a rename on the record (userRenamed), so a panel writes it here.
+      out.features = { routing: !!router, computer: computerSupported(), testDensity: true, rename: true };
       out.budget = sessionMoney(record.id);
       out.remoteLevel = policy ? effectiveLevel(policy, { untrusted: live.turnUntrusted === true, now: now() }) : null;
     }
@@ -1119,7 +1185,7 @@ export function createAssistantRuntime({
       fidelity: row.fidelity || settled?.fidelity, reason: row.reason ?? settled?.reason ?? null, source: row.source || settled?.source,
     });
     if (estimate && costUsd > 0) {
-      live.record.costUsd = Number(((Number(live.record.costUsd) || 0) + costUsd).toFixed(4));
+      addBrainCost(live, costUsd, 'claude-code');
       try { dispatcher?.checkSession?.(id); } catch {}
       sendCost(live);
     }
@@ -1177,16 +1243,18 @@ export function createAssistantRuntime({
           // session restarted (resume, brain switch), so it counts in full.
           const last = Number(live.record.lastReportedCost) || 0;
           const delta = cost >= last ? cost - last : cost;
-          live.record.costUsd = Number(((Number(live.record.costUsd) || 0) + delta).toFixed(4));
+          addBrainCost(live, delta, live.brainProvider || live.record.brain?.provider || null);
           live.record.lastReportedCost = cost;
           live.record.costBasis = event.cost_basis || 'reported';
-          // The brain's spend counts toward the session caps: warn, or stop the session's runs.
+          // The brain's spend counts toward the session budget: warn, or stop the session's runs.
           try { dispatcher?.checkSession?.(id); } catch {}
           sendCost(live);
         }
         // The Claude CLI's own cap stopped the brain: its process cannot run another turn.
         if (event.subtype === 'error_max_budget_usd' && live.brainProvider === 'claude-code') live.brainCapHit = true;
         if (live.planTurn) live.planText = planTurnText(event);
+        // The reply the user's next message answers (context for the learning loop; a subagent's result is not it).
+        if (typeof event.result === 'string' && event.result.trim() && !event.parent_tool_use_id) live.lastReply = clip(event.result, 600);
         touch(live);
       }
       if (TRANSCRIPT_EVENT_TYPES.has(event.type) && !(event.type === 'system' && event.subtype !== 'init')) appendTranscript(id, { at: iso(now()), packet });
@@ -1292,8 +1360,32 @@ export function createAssistantRuntime({
       }
     }
     sendToSockets(live, packet);
+    // After the packet: the turn's trace moves under the reply the panel has just closed.
+    if ((packet.type === 'done' || packet.type === 'aborted' || packet.type === 'error') && !live.running) finishUserContextTurn(live, packet.type);
     if (plan) offerPlanCard(live, plan, planGen);
   }
+  /** The oldest human turn still open ended: its trace moves under the reply and learning starts, off the reply path. */
+  function finishUserContextTurn(live, outcome) {
+    const handle = live.ucTurns.shift();
+    if (!handle || !userContext) return;
+    try { userContext.endTurn(live.record, handle, { outcome }); } catch (error) { log('assistant:user-context', error?.message || String(error)); }
+  }
+  /** One turn's user-context trace: to the panel and into the journal, a full snapshot each time (the panel upserts by traceId). */
+  function emitAutomation(live, event) {
+    if (!event || sessions.get(live.record.id) !== live) return;
+    const packet = { type: 'event', event };
+    sendToSockets(live, packet);
+    appendTranscript(live.record.id, { at: iso(now()), packet });
+  }
+  /** The cards of a session left unanswered right now: the runtime's plan card, route cards, clarify cards. */
+  function openCards(live) {
+    const out = [];
+    const title = (card) => clip(card?.request?.title || card?.request?.summary || card?.request?.route?.summary || card?.request?.questions?.[0]?.question || '', 80);
+    if (live.planCard?.requestId) out.push({ id: String(live.planCard.requestId), kind: 'plan', title: clip(String(live.planCard.plan || '').split('\n')[0], 80) });
+    try { for (const card of router?.pendingCards?.(live.record.id) || []) if (card?.request_id) out.push({ id: String(card.request_id), kind: 'route', title: title(card) }); } catch {}
+    try { for (const card of clarifier?.pendingCards?.(live.record.id) || []) if (card?.request_id) out.push({ id: String(card.request_id), kind: 'question', title: title(card) }); } catch {}
+    return out;
+  }
   /**
    * Codex and OpenCode end a plan turn with the plan instead of asking for
    * approval the way Claude's ExitPlanMode does: the runtime asks, with the same
@@ -1631,13 +1723,54 @@ export function createAssistantRuntime({
   }
   /** The brain's own spend in a session (the dispatcher adds it to the session total). */
   function brainSpend(sessionId) { return Number(sessions.get(sessionId)?.record.costUsd) || 0; }
-  /** Brain cap (USD per session): the Budget tab's value, read live. */
-  function brainCapUsd() {
-    try { const value = Number(configStore?.budget?.().brainUsd); if (value > 0) return value; } catch {}
-    return settings.maxBudgetUsd;
+  /**
+   * Book the brain's spend: its session total and the provider it ran on (the budget counts the
+   * brain's turns in that provider's share).
+   */
+  function addBrainCost(live, usdAmount, provider) {
+    const added = Number(usdAmount);
+    if (!Number.isFinite(added) || added <= 0) return;
+    live.record.costUsd = Number(((Number(live.record.costUsd) || 0) + added).toFixed(4));
+    const key = BRAIN_PROVIDERS.has(provider) ? provider : (live.record.brain?.provider || 'claude-code');
+    const rows = live.record.costByProvider && typeof live.record.costByProvider === 'object' ? live.record.costByProvider : {};
+    rows[key] = Number(((Number(rows[key]) || 0) + added).toFixed(8));
+    live.record.costByProvider = rows;
+  }
+  /**
+   * The brain's spend by the provider it ran on. A session recorded before this was kept books what
+   * no provider holds on the brain's provider.
+   */
+  function brainSpendByProvider(sessionId) {
+    const record = sessions.get(sessionId)?.record;
+    if (!record) return {};
+    const rows = record.costByProvider && typeof record.costByProvider === 'object' ? { ...record.costByProvider } : {};
+    const known = Object.values(rows).reduce((sum, value) => sum + (Number(value) || 0), 0);
+    const rest = (Number(record.costUsd) || 0) - known;
+    if (rest > 0.00005) {
+      const key = BRAIN_PROVIDERS.has(record.brain?.provider) ? record.brain.provider : 'claude-code';
+      rows[key] = (Number(rows[key]) || 0) + rest;
+    }
+    return rows;
+  }
+  /** The session budget: the injected planner, else the dispatcher's. */
+  function planner() { return budgetPlanner || dispatcher?.budget || null; }
+  /** The budget setting now ({ unlimited, amountUsd, version }), or null when nothing keeps one. */
+  function budgetSettingNow() {
+    try { const value = planner()?.setting?.() || configStore?.budget?.() || null; return value ? { unlimited: value.unlimited === true, amountUsd: Number(value.amountUsd) || 0, version: Number(value.version) || 0 } : null; } catch { return null; }
+  }
+  /** The "[SynaBun Budget]" line when the setting changed since the brain last saw it (then marked seen), else ''. */
+  function budgetLine(live) {
+    try {
+      const stamp = budgetStamp(budgetSettingNow(), sessionMoney(live.record.id));
+      if (!stamp.key) return '';
+      if (live.budgetStampKey === undefined) { live.budgetStampKey = stamp.key; return ''; }
+      if (live.budgetStampKey === stamp.key) return '';
+      live.budgetStampKey = stamp.key;
+      return stamp.text;
+    } catch { return ''; }
   }
   function sessionMoney(sessionId) {
-    try { return dispatcher?.sessionBudget?.(sessionId) || null; } catch { return null; }
+    try { return dispatcher?.sessionBudget?.(sessionId) || planner()?.view?.(sessionId) || null; } catch { return null; }
   }
   /**
    * How the brain's spend is known: 'reported' (Claude; OpenCode with a list
@@ -1662,34 +1795,91 @@ export function createAssistantRuntime({
   function sendCost(live) {
     const budget = sessionMoney(live.record.id);
     const basis = brainCostBasis(live);
-    sendToSockets(live, { type: 'assistant:cost', sessionUsd: live.record.costUsd, dispatchUsd: dispatchSpend(live.record.id), budget, brainCapUsd: brainCapUsd(), brainMetered: basis !== null, brainCostBasis: basis });
+    sendToSockets(live, { type: 'assistant:cost', sessionUsd: live.record.costUsd, dispatchUsd: dispatchSpend(live.record.id), budget, brainMetered: basis !== null, brainCostBasis: basis });
   }
   /**
-   * Why the brain may not start a turn: the session's hard cap (brain + agents)
-   * or the brain cap, checked before every turn. A turn already running
-   * finishes; the Claude CLI also gets the remaining brain budget as its own cap.
+   * The session's budget as it is now, live: `assistant:budget` to the session's sockets and the sync
+   * channel (every window), after a split or a change of the budget. `reason`: what made it.
+   */
+  function sendBudget(sessionId, budget = null, { reason = null } = {}) {
+    const live = sessions.get(String(sessionId || ''));
+    if (!live) return;
+    const view = budget || sessionMoney(live.record.id);
+    if (!view) return;
+    const packet = { type: 'assistant:budget', sessionId: live.record.id, reason: reason || null, budget: view };
+    // A view, not an event (like usage): the open sockets only, never buffered (attach sends a fresh one).
+    const raw = JSON.stringify(packet);
+    for (const ws of [...live.sockets]) { if (ws.readyState === 1) { try { ws.send(raw); } catch {} } }
+    try { broadcastSync({ ...packet, assistantSessionId: live.record.id }); } catch {}
+  }
+  /**
+   * Why the brain may not start a turn, checked before every turn (a turn already running finishes):
+   * an unpriced brain model, the session's budget spent, or no money left in the brain's provider
+   * share (runTurn divides the session's unspent budget again first). Nothing under No limit.
    */
   function brainBudgetBlock(live) {
-    // Fail closed: a brain whose spend has no price could spend past every cap.
+    const money = sessionMoney(live.record.id);
+    if (!money || money.unlimited) return null;
+    // Fail closed: a brain whose spend has no price could spend past the budget.
     if (pricing && brainCostBasis(live) === null) {
       const model = live.record.brain?.model || brainCapabilities(live.record)?.id || 'its default model';
-      return { code: 'BRAIN_UNPRICED', message: `No price is known for the ${live.record.brain?.provider || ''} brain model ${model}, so the budget caps cannot hold its spend. Pick a priced or free model for the brain.` };
+      return { code: 'BRAIN_UNPRICED', message: `No price is known for the ${live.record.brain?.provider || ''} brain model ${model}, so the session budget cannot hold its spend. Pick a priced or free model for the brain, or switch the budget to No limit.` };
     }
-    const money = sessionMoney(live.record.id);
-    if (money && money.totalUsd >= money.hardUsd) {
-      return { code: 'SESSION_BUDGET_EXCEEDED', message: `This session spent ${usd(money.totalUsd)} (brain ${usd(money.brainUsd)} + agents ${usd(money.dispatchUsd)}), at its hard cap of ${usd(money.hardUsd)}. Raise the cap in ⋯ → Budget… to continue.` };
+    if (money.exceeded) {
+      return { code: 'SESSION_BUDGET_EXCEEDED', message: `This session spent ${usd(money.totalUsd)} of its ${usd(money.amountUsd)} budget (brain ${usd(money.brainUsd)} + agents ${usd(money.dispatchUsd)}). Raise the budget or switch to No limit in ⋯ → Budget… to continue.` };
+    }
+    const provider = live.record.brain?.provider || null;
+    const covered = planner()?.covers?.(live.record.id, { provider, forBrain: true });
+    if (covered === false) {
+      return { code: 'BRAIN_SHARE_EXHAUSTED', share: true, message: `The ${provider} share of this session's budget is used up, so the brain cannot take another turn (${usd(money.leftUsd)} of the ${usd(money.amountUsd)} budget left in other providers' shares). Raise the budget or switch to No limit in ⋯ → Budget… to continue.` };
     }
-    const cap = brainCapUsd();
-    const spent = Number(live.record.costUsd) || 0;
-    if (spent >= cap) return { code: 'BRAIN_BUDGET_EXCEEDED', message: `The brain spent ${usd(spent)} in this session, at its cap of ${usd(cap)}. Raise the brain cap in ⋯ → Budget… to continue.` };
     return null;
   }
-  /** The Budget tab saved new caps: held mailbox items may go now, and every open panel refreshes its chip. */
+  /**
+   * The planner divided a session's budget again (budget planner `emit`): the panels hear it, and a
+   * mailbox the brain's empty share held goes now.
+   */
+  function onBudgetSplit(sessionId, budget = null, { reason = null } = {}) {
+    sendBudget(sessionId, budget, { reason });
+    const live = sessions.get(String(sessionId || ''));
+    if (live && live.mailbox.length && !brainBudgetBlock(live)) { live.budgetHoldNotified = false; live.budgetShareTriedAt = 0; scheduleMailbox(live, 0); }
+  }
+  /**
+   * Before a brain turn: when the brain's provider share is used up but the session has money left,
+   * the session's unspent budget is divided again (its reserve comes back with the new split).
+   */
+  async function coverBrainTurn(live) {
+    const budget = planner();
+    if (!budget?.ensureCovered || !budget.limited?.()) return true;
+    try { return await budget.ensureCovered(live.record.id, { provider: live.record.brain?.provider || null, forBrain: true, reason: 'brain_turn' }); }
+    catch { return false; }
+  }
+  /**
+   * The Claude brain CLI's own stop (--max-budget-usd): what its provider's share has left for it when
+   * it starts, never more than the session has left. null under No limit (no CLI cap at all).
+   */
+  function brainCliCap(live) {
+    const money = sessionMoney(live.record.id);
+    if (!money || money.unlimited) return null;
+    let left = Number(money.leftUsd) || 0;
+    try {
+      const cov = planner()?.coverage?.(live.record.id);
+      if (cov && Number.isFinite(Number(cov.brainLeftUsd))) left = Math.min(left, Number(cov.brainLeftUsd));
+    } catch { /* the session's own left */ }
+    return Math.max(MIN_SPEND_USD, floorCents(left) / 100);
+  }
+  /**
+   * The budget changed (Assistant → Budget): the planner divides each open session's budget again,
+   * held mailbox items may go now, and every open panel refreshes its chip and split.
+   */
   function onBudgetChanged() {
+    try { planner()?.onBudgetChanged?.(); } catch {}
     for (const live of sessions.values()) {
       if (live.record.status === 'ended') continue;
+      live.budgetShareTriedAt = 0;
       try { dispatcher?.checkSession?.(live.record.id); } catch {}
       sendCost(live);
+      sendBudget(live.record.id, null, { reason: 'budget_changed' });
       if (live.mailbox.length && !brainBudgetBlock(live)) { live.budgetHoldNotified = false; scheduleMailbox(live, 0); }
     }
   }
@@ -1703,6 +1893,12 @@ export function createAssistantRuntime({
     try { if (catalogValue?.models) sheet = selectSheetModels(catalogValue, { brain, preferences: routingCfg.preferences || {}, max: 8 }); } catch {}
     let setupState = null;
     try { setupState = desktop?.setupState?.() || null; } catch {}
+    // This prompt states the level: a "[SynaBun Tests]" line follows only a later change.
+    live.testDensityStamp = testDensityStamp(testDensityOf(live.record));
+    // …and the budget: a "[SynaBun Budget]" line follows only a later change of the setting.
+    const budgetSetting = budgetSettingNow();
+    const money = sessionMoney(live.record.id);
+    live.budgetStampKey = budgetStamp(budgetSetting, money).key;
     return buildAssistantPersona({
       assistantSessionId: live.record.id,
       brain,
@@ -1721,6 +1917,9 @@ export function createAssistantRuntime({
       // A remote session: what remoteComputerUse says for it (a turn with untrusted content is asked either way).
       computer: { available: computerSupported(), enabled: computerEffective(live.record), setupState, remote: computerDecision(live, { untrusted: false }) },
       taskClasses: TASK_CLASS_META,
+      testDensity: testDensityOf(live.record),
+      // The session budget as the brain starts: the setting and, with a budget, the split so far.
+      budget: budgetSetting ? { ...budgetSetting, view: money } : null,
       clarify: !!clarifier,
       channel: live.record.channel || live.record.remote?.channel || null,
     });
@@ -1742,9 +1941,18 @@ export function createAssistantRuntime({
     if (remote) live.record.brain = clampedBrain(live, live.record.brain);
     const brain = live.record.brain;
     const sink = { send: (packet) => onBrainPacket(live, packet) };
-    const persona = await personaFor(live);
+    const basePersona = await personaFor(live);
     if (stale()) return null;
     if (live.brain) return live.brain;
+    // What SynaBun has learned about the user rides after the persona, in the same system-level
+    // slot (Claude systemPromptAppend, Codex developerInstructions, OpenCode agent prompt), frozen
+    // per provider conversation so the prompt cache holds.
+    let userSuffix = { text: '', key: null, nudges: false };
+    if (userContext) {
+      try { userSuffix = userContext.personaSuffix(live.record) || userSuffix; }
+      catch (error) { log('assistant:user-context', error?.message || String(error)); }
+    }
+    const persona = userSuffix.text ? `${basePersona}\n\n${userSuffix.text}` : basePersona;
     live.personaText = persona;
     // Computer use: one unforgeable grant per brain (the MCP `computer` group is
     // advertised only to callers presenting it). Revoked when the brain goes.
@@ -1762,11 +1970,15 @@ export function createAssistantRuntime({
         live.computerGrantLive = false;
       } catch (error) { log('assistant:desktop-grant-error', error?.message || String(error)); }
     }
+    // whatsapp_send_file: one credential per brain launch of a WhatsApp conversation (BRAIN_CREDENTIAL_RE),
+    // for that brain's SynaBun MCP server alone. Every other session's brain gets none.
+    live.brainCredential = (live.record.channel || live.record.remote?.channel) === 'whatsapp' ? mintBrainCredential() : null;
+    const cliCap = brain.provider === 'claude-code' ? brainCliCap(live) : null;
     const deps = {
       ClaudeSession, sdkVersion, PACKAGE_ROOT, handleCodexSkinWebSocket, ensureIsolatedServe, stopIsolatedServe, setupOpencodeSidepanelConfig,
       claudeAccountEnv: (accountId) => (claudeAccounts?.envFor?.(accountId) || {}),
-      // The Claude CLI caps this process at what the session's brain budget has left.
-      maxBudgetUsd: Math.max(0.1, Math.round((brainCapUsd() - (Number(live.record.costUsd) || 0)) * 100) / 100),
+      // The Claude CLI caps this process at what the brain's provider share has left (none under No limit).
+      maxBudgetUsd: cliCap ?? undefined,
       // A Codex brain reports tokens: priced at the list price of its model (estimated).
       priceCodexUsage: (usage) => {
         const price = codexBrainPrice(live);
@@ -1782,6 +1994,7 @@ export function createAssistantRuntime({
       // Also a resume into another session: what the meter counts as the main loop follows it.
       onOpenCodeRoot: (sessionId) => { live.record.providerSessionId = sessionId; metered('meter-state', () => live.brainMeter?.setRoot?.(sessionId)); saveMeter(live); },
       desktopGrant: live.desktopGrant || null,
+      brainCredential: live.brainCredential || null,
       // A remote session's level (lib/remote-policy.js): the Claude brain allows
       // bypass only at autonomous. null for a desktop session.
       remoteLevel: remote ? effectiveLevel(remote, { now: now() }) : null,
@@ -1790,6 +2003,8 @@ export function createAssistantRuntime({
       // A Codex / OpenCode brain of a remote session is read-only for good: the
       // read-only sandbox (Codex), the plan agent (OpenCode), no auto-accept.
       remoteReadOnly: !!remote && remoteBrainLimited(brain.provider),
+      // The engine keeps this conversation's thread record: pre-compact.mjs asks for no conversation memory.
+      userContextThreads: brain.provider === 'claude-code' && userSuffix.nudges === true,
     };
     const gate = ensureGate(live);
     // A remote session's hook / plugin refuses a call it could not check (fail closed).
@@ -1805,22 +2020,29 @@ export function createAssistantRuntime({
     const memoryHooks = brain.provider === 'claude-code' && memory?.claudeHooks ? memory.claudeHooks({
       session: live.record.id, project: live.record.project || 'global',
       getGeneration: () => live.record.memoryGeneration || 1,
-      bumpGeneration: () => { live.record.memoryGeneration = (live.record.memoryGeneration || 1) + 1; touch(live); },
+      bumpGeneration: () => { live.record.memoryGeneration = (live.record.memoryGeneration || 1) + 1; try { userContext?.onCompaction(live.record); } catch {} touch(live); },
       markRemembered: () => { live.rememberedThisTurn = true; live.obligations.clear(); },
       hasPendingObligations: () => live.obligations.size > 0 && !live.rememberedThisTurn,
       onRecall: (recalled) => { if (recalled?.results?.length || recalled?.alreadyPresent) sendToSockets(live, { type: 'event', event: { type: 'synabun.memories', memories: recalled.results || [], alreadyPresent: !!recalled.alreadyPresent } }); },
       describeTurn: (text) => describeTurn(live, text),
+      // User context: its categories stay out of Related Memories, and its per-turn block follows them.
+      divert: () => userContext?.divertCategories() || null,
+      turnContext: ({ recalled, meta }) => (userContext && meta?.uc ? userContext.turnBlock(live.record, meta.uc, recalled).text : ''),
     }) : null;
     // Claude: memory, the route gate, the browser policy (every session: plan mode and subagents too), a remote session's hook.
     const claude = brain.provider === 'claude-code';
     const hooks = mergeHooks(mergeHooks(mergeHooks(memoryHooks, claude && gate ? gateHooks(live) : null), claude ? browserHooks(live) : null), claude && (remote || live.record.remote) ? remoteHooks(live) : null);
     live.brainProvider = brain.provider;
+    // What the CLI cap was sized from: a later change of the budget restarts a Claude brain (runTurn).
+    live.brainCliCap = cliCap;
+    live.brainBudgetVersion = budgetSettingNow()?.version ?? null;
     startMeter(live, brain.provider);
     const created = factory({ session: live.record, sink, deps, persona, hooks });
     live.brain = created;
     live.brainSkipAllowed = remote ? deps.remoteLevel === 'autonomous' : null;
     live.brainComputerMode = computerMode;
     live.brainRemoteReadOnly = deps.remoteReadOnly === true;
+    live.brainUserContext = userSuffix.key;
     live.record.status = 'idle';
     touch(live);
     try { await created.start?.(); } catch (error) {
@@ -1845,6 +2067,8 @@ export function createAssistantRuntime({
       if (identity.providerThreadId) live.record.providerThreadId = identity.providerThreadId;
     } catch {}
     live.brain = null;
+    // Its credential dies with it: a file send presenting it is refused from here on.
+    live.brainCredential = null;
     if (live.brainProvider === 'codex') pollCodex(live, { force: true });
     // No further turn will book them: a Claude brain's provisional tokens are booked as an estimate,
     // any other brain's go (Codex was just polled, OpenCode settled at its turn's end).
@@ -1858,6 +2082,9 @@ export function createAssistantRuntime({
     live.running = false;
     closePlanCard(live, 'brain_disposed');
     live.planTurn = false;
+    live.brainUserContext = null;
+    // A human turn the brain took with it never ends on its own: its trace and its learning close here.
+    for (const handle of live.ucTurns.splice(0)) { try { userContext?.endTurn(live.record, handle, { outcome: 'aborted' }); } catch {} }
     // A remote session's computer use ends with its brain: the turn's approval, its open request, the live grant.
     endComputerTurn(live, reason === 'closed' ? 'session_closed' : 'brain_disposed');
     settleNativeQuestions(live, 'brain_disposed');
@@ -1984,13 +2211,15 @@ export function createAssistantRuntime({
     }
   }
   // `authority`: the WhatsApp bridge's capability; it alone makes a prompt count as the owner's own
-  // plain message from the phone (fromPhone). `origin` below is audit text and decides nothing.
-  // `origin`: who wrote a human prompt ('ui', 'whatsapp', 'api'); `untrusted`: its
+  // plain message from the phone (fromPhone). `origin` below is audit text and where an answer goes
+  // (a continuation's, to the chat its prompt came from); it grants nothing.
+  // `origin`: who wrote a human prompt ('ui', 'whatsapp', 'api'), or for a route continuation
+  // (`work.kind` 'continuation') who wrote the prompt it carries on; `untrusted`: its
   // text carries content the owner did not write (a remote session caps it at ask).
   // `offerPlan`: a system turn that revises a plan still ends with a plan card.
   // `work`: the scheduler entry this system turn is; `request`: { id, reply } of a
   // prompt a socket sent (refuse); `turnGen`: the generation runQuery entered in.
-  async function runTurn(live, { text, images = [], cwd = null, model = null, effort = null, permissionMode = null, planMode = null, system = false, taskId = null, turnModel = null, turnEffort = null, gateOpen = false, gateCarry = false, origin = null, authority = null, untrusted = false, offerPlan = false, work = null, request = null, turnGen = live.gen, computerRoutes = null } = {}) {
+  async function runTurn(live, { text, images = [], cwd = null, model = null, effort = null, permissionMode = null, planMode = null, system = false, taskId = null, turnModel = null, turnEffort = null, gateOpen = false, gateCarry = false, origin = null, authority = null, untrusted = false, offerPlan = false, work = null, request = null, turnGen = live.gen, computerRoutes = null, typed = null, greetingId = null } = {}) {
     const prompt = String(text || '').trim();
     if (!prompt && !(Array.isArray(images) && images.length)) return refuse(live, 'EMPTY_PROMPT', 'No prompt provided', { packet: { type: 'error', message: 'No prompt provided' }, request });
     // The scheduler's turn goes once a Stop, the session closing or a newer
@@ -2012,13 +2241,26 @@ export function createAssistantRuntime({
       try { await catalog.full(); } catch {}
       if (cancelled()) return dropTurn(live, request);
     }
-    const budgetBlock = brainBudgetBlock(live);
+    let budgetBlock = brainBudgetBlock(live);
+    // The brain's provider share is used up but the session has money left: it is divided again first.
+    if (budgetBlock?.share && await coverBrainTurn(live)) {
+      if (cancelled()) return dropTurn(live, request);
+      budgetBlock = brainBudgetBlock(live);
+    }
     if (budgetBlock) return refuse(live, budgetBlock.code, budgetBlock.message, { request });
+    // A Claude brain whose account cannot run (signed out, its key unreadable, removed) is refused with
+    // why, before a process starts under it: the CLI would only answer "not logged in" mid-turn.
+    if (!live.brain && ['claude-code', 'codex'].includes(live.record.brain?.provider)) {
+      const unusable = live.record.brain.provider === 'codex' ? codexAccountUnusable(live.record.brain.accountId) : claudeAccountUnusable(live.record.brain.accountId);
+      if (unusable) return refuse(live, 'ACCOUNT_SIGNED_OUT', `${unusable} Pick another account in the brain picker, or sign it in from its Account menu → Manage….`, { request });
+    }
     // A remote session: a human prompt sets the trust of this turn and the ones it leads to.
     const remote = remotePolicyFor(live);
     if (!system) live.turnUntrusted = untrusted === true;
-    // A Claude brain its CLI cap stopped restarts with the budget it has now.
-    if (live.brainCapHit && live.brain && !live.running) {
+    // A Claude brain its CLI cap stopped restarts with the budget it has now, and so does one whose
+    // budget setting changed since it started (a raise, a cut, No limit: no CLI cap at all).
+    const budgetMoved = live.brainProvider === 'claude-code' && live.brainBudgetVersion !== undefined && live.brainBudgetVersion !== (budgetSettingNow()?.version ?? null);
+    if ((live.brainCapHit || budgetMoved) && live.brain && !live.running) {
       live.brainCapHit = false;
       await disposeBrain(live, 'budget');
       if (cancelled()) return dropTurn(live, request);
@@ -2049,15 +2291,19 @@ export function createAssistantRuntime({
       return refuse(live, 'ASSISTANT_BUSY', BUSY_MESSAGE, { packet: { type: 'error', message: BUSY_MESSAGE, code: 'ASSISTANT_BUSY' }, request });
     }
     let finalText = prompt;
+    // A Codex / OpenCode turn's recall result, for the user-context block below.
+    let turnRecalled = null;
     if (!system) {
       live.lastPrompt = prompt;
+      live.lastPromptOrigin = origin ? String(origin) : null;
       // A prompt from elsewhere (WhatsApp, the API) is news to the panel: it goes live too.
       const promptPacket = { type: 'event', event: { type: 'synabun.user_prompt', text: prompt, images: images.length, ...(origin && origin !== 'ui' ? { origin: String(origin) } : {}) } };
       appendTranscript(live.record.id, { at: iso(now()), packet: promptPacket });
       if (origin && origin !== 'ui') sendToSockets(live, promptPacket);
       if (live.brainProvider !== 'claude-code' && memory?.recallForPrompt) {
         let recalled = null;
-        try { recalled = await memory.recallForPrompt({ prompt, project: live.record.project, session: live.record.id, generation: live.record.memoryGeneration || 1 }); } catch {}
+        try { recalled = await memory.recallForPrompt({ prompt, project: live.record.project, session: live.record.id, generation: live.record.memoryGeneration || 1, divert: userContext?.divertCategories() || null }); } catch {}
+        turnRecalled = recalled;
         // Closed while it recalled: the session that reopened hears nothing of this prompt, and its record keeps what came since.
         if (cancelled()) return dropTurn(live, request);
         try {
@@ -2087,6 +2333,19 @@ export function createAssistantRuntime({
           }
         } catch {}
       }
+      // Test density changed since the brain last saw it (the same place, after the router's line).
+      // Its prompt states the level it starts with (personaFor), so only a change is a line.
+      try {
+        const tests = testDensityStamp(testDensityOf(live.record));
+        if (live.testDensityStamp === undefined) live.testDensityStamp = tests;
+        else if (live.testDensityStamp !== tests) {
+          finalText = finalText.endsWith(prompt) ? `${finalText.slice(0, finalText.length - prompt.length)}${tests}\n\n${prompt}` : `${tests}\n\n${finalText}`;
+          live.testDensityStamp = tests;
+        }
+      } catch {}
+      // The budget changed since the brain last saw it: one "[SynaBun Budget]" line, in the same place.
+      const budgetNote = budgetLine(live);
+      if (budgetNote) finalText = finalText.endsWith(prompt) ? `${finalText.slice(0, finalText.length - prompt.length)}${budgetNote}\n\n${prompt}` : `${budgetNote}\n\n${finalText}`;
       // A new request cycle. Open clarify questions make this message the
       // user's reply (assistant-clarify.js); otherwise the last brief retires.
       live.promptCycle += 1;
@@ -2123,6 +2382,14 @@ export function createAssistantRuntime({
     }
     // The last check: from here on the turn is the brain's.
     if (cancelled()) return dropTurn(live, request);
+    // A route continuation starts: before any of its output, every host and observer hears where the
+    // prompt it carries on came from (the WhatsApp bridge answers the chat that started the task).
+    // It stays a system turn: no user_prompt, no new request cycle, nothing granted (computer use asks).
+    if (system && work?.kind === 'continuation') {
+      const continued = { type: 'event', event: { type: 'synabun.continuation', origin: origin ? String(origin) : null } };
+      appendTranscript(live.record.id, { at: iso(now()), packet: continued });
+      sendToSockets(live, continued);
+    }
     if (usage) {
       taskId ||= live.record.taskId || ensureTaskId(live.record.id);
       // record.taskId is the latest human task: a system turn that carries its own names only its turn.
@@ -2132,8 +2399,8 @@ export function createAssistantRuntime({
       else live.turnTaskId = taskId;
       scheduleUsage(live.record.id);
     }
-    // A remote session runs every turn at what its level allows now (an expired
-    // autonomous window, an untrusted prompt): the modes go to the brain with the turn.
+    // A remote session runs every turn at what its level allows now (a pause, an
+    // untrusted prompt): the modes go to the brain with the turn.
     if (remote) live.record.brain = clampedBrain(live, live.record.brain);
     // A Codex / OpenCode plan turn ends with the plan, not an approval request: the runtime asks.
     // (runQuery already closed the plan card this turn replaces.)
@@ -2149,7 +2416,8 @@ export function createAssistantRuntime({
     live.record.lastActiveAt = iso(now());
     live.turnStartedMs = now();
     live.record.turns = (Number(live.record.turns) || 0) + 1;
-    if (isDefaultSessionTitle(live.record.title)) {
+    // A name the user gave (updateSession) is never replaced, whatever it says.
+    if (!live.record.userRenamed && isDefaultSessionTitle(live.record.title)) {
       if (!system) { live.record.title = clip(prompt.split('\n')[0], 60); broadcast('assistant:session-updated', live); }
     }
     touch(live);
@@ -2157,12 +2425,48 @@ export function createAssistantRuntime({
     // the record, and routed/continuation turns override it for one turn only.
     const effectiveModel = turnModel || live.record.brain.model || null;
     const effectiveEffort = brainEffort(live.record.brain.provider, effectiveModel, turnEffort || live.record.brain.effort || null);
+    // User context (assistant-user-context.js): a human turn's trace and learning start here.
+    // A Codex / OpenCode turn gets its per-turn block now (its recall result is known); a Claude
+    // turn gets it in the in-process UserPromptSubmit hook, which finds the handle in turnMeta.
+    let ucTurn = null;
+    // Greeting (lib/greeting/): a human turn is the person being here, and the greeting the panel
+    // showed when this conversation opened is told to the brain once, as background (never for a
+    // slash command). The user-context block carries it when that engine runs; else it goes in
+    // front of the user's words by itself.
+    let greeted = null;
+    if (!system && greeting) {
+      try { greeting.noteActivity({ project: live.record.project || null, cwd: live.record.brain.cwd || null, surface: 'assistant', words: typed || prompt }); } catch { /* the turn goes on */ }
+      if (greetingId) {
+        try {
+          const shown = greeting.peek(greetingId);
+          const note = greeting.consumeNote(greetingId, { skip: prompt.trimStart().startsWith('/') });
+          if (note && shown) greeted = { id: shown.id, text: shown.text, note, ids: (shown.basis || []).map((row) => row.id).filter(Boolean), source: shown.source, model: shown.model, costUsd: shown.costUsd };
+        } catch { greeted = null; }
+      }
+    }
+    if (!system && userContext) {
+      try {
+        ucTurn = userContext.beginTurn(live.record, {
+          prompt, typed, origin: origin || null, untrusted: untrusted === true, generation: live.record.memoryGeneration || 1,
+          previousReply: live.lastReply || '', cwd: live.record.brain.cwd || null, taskId, greeting: greeted,
+          emit: (event) => emitAutomation(live, event), persist: () => touch(live), openCards: () => openCards(live),
+        });
+        if (live.brainProvider !== 'claude-code') {
+          const block = userContext.turnBlock(live.record, ucTurn, turnRecalled).text;
+          // After the memories and the router / test lines, right before the user's words.
+          if (block) finalText = finalText.endsWith(prompt) ? `${finalText.slice(0, finalText.length - prompt.length)}${block}\n\n${prompt}` : `${block}\n\n${finalText}`;
+        }
+        live.ucTurns.push(ucTurn);
+      } catch (error) { ucTurn = null; log('assistant:user-context', error?.message || String(error)); }
+    }
+    // No user-context engine to carry it: the note goes right before the user's words.
+    if (greeted && !ucTurn) finalText = finalText.endsWith(prompt) ? `${finalText.slice(0, finalText.length - prompt.length)}${greeted.note}\n\n${prompt}` : `${greeted.note}\n\n${finalText}`;
     // The Claude brain recalls in its UserPromptSubmit hook, which sees only the
     // final text: record who wrote it (mailbox / router = system) and the user's
     // own words, so a router-stamped first turn recalls on the prompt itself.
     if (live.brainProvider === 'claude-code' && finalText.trim()) {
       live.turnMeta.delete(finalText.trim());
-      live.turnMeta.set(finalText.trim(), { system: !!system, prompt: system ? null : prompt });
+      live.turnMeta.set(finalText.trim(), { system: !!system, prompt: system ? null : prompt, ...(ucTurn ? { uc: ucTurn } : {}) });
       while (live.turnMeta.size > 8) live.turnMeta.delete(live.turnMeta.keys().next().value);
     }
     // Every turn starts unrouted; a continuation or a route_decided "here" turn starts open.
@@ -2181,6 +2485,12 @@ export function createAssistantRuntime({
       scheduleUsage(live.record.id);
       live.planTurn = false;
       live.record.status = 'idle';
+      // The prompt never reached the brain: nothing is traced or learned from it.
+      if (ucTurn) {
+        const at = live.ucTurns.indexOf(ucTurn);
+        if (at >= 0) live.ucTurns.splice(at, 1);
+        try { userContext?.cancelTurn(live.record, ucTurn); } catch {}
+      }
       const message = error?.message || String(error);
       sendToSockets(live, { type: 'error', message });
       sendToSockets(live, { type: 'done', code: 1 });
@@ -2227,10 +2537,24 @@ export function createAssistantRuntime({
     try { mark = dispatcher?.deliveryState?.(item.run.runId) || null; } catch { mark = null; }
     return !!mark && Number(mark.turn) >= turn;
   }
-  /** Out of money: the events wait (the Budget tab re-schedules them after a raise), said once. */
+  /**
+   * Out of money: the events wait (a raise or No limit re-schedules them), said once. The brain's
+   * provider share used up while the session has money left: the budget is divided again, then the
+   * mailbox goes.
+   */
   function mailboxAllowed(live) {
     const budgetBlock = brainBudgetBlock(live);
     if (!budgetBlock) return true;
+    if (budgetBlock.share && !live.budgetCovering && !(live.budgetShareTriedAt && now() - live.budgetShareTriedAt < 10_000)) {
+      live.budgetCovering = true;
+      coverBrainTurn(live).then((covered) => {
+        live.budgetCovering = false;
+        live.budgetShareTriedAt = covered ? 0 : now();
+        if (live.mailbox.length) scheduleMailbox(live, 0);
+      }).catch(() => { live.budgetCovering = false; live.budgetShareTriedAt = now(); });
+      return false;
+    }
+    if (live.budgetCovering) return false;
     if (!live.budgetHoldNotified) {
       live.budgetHoldNotified = true;
       sendToSockets(live, { type: 'error', code: budgetBlock.code, message: `${budgetBlock.message} ${live.mailbox.length} agent event${live.mailbox.length === 1 ? '' : 's'} will reach the brain after that.` });
@@ -2261,7 +2585,9 @@ export function createAssistantRuntime({
     let sessionRuns = [];
     try { sessionRuns = unread.some((item) => item?.kind === 'route_decided') ? (dispatcher?.list?.({ assistantSessionId: live.record.id, limit: 500 }) || []) : []; } catch { sessionRuns = []; }
     const items = reconcileRouteItems(unread, sessionRuns);
-    const text = formatMailbox(items);
+    // A budget change since the brain last saw it rides first (a raise is what released a held mailbox).
+    const budgetNote = budgetLine(live);
+    const text = budgetNote ? `${budgetNote}\n\n${formatMailbox(items)}` : formatMailbox(items);
     sendToSockets(live, { type: 'event', event: { type: 'synabun.mailbox', items } });
     appendTranscript(live.record.id, { at: iso(now()), packet: { type: 'event', event: { type: 'synabun.mailbox', items } } });
     live.mailboxTurn = true;
@@ -2281,6 +2607,8 @@ export function createAssistantRuntime({
     if (!run?.assistantSessionId) return;
     const live = sessions.get(run.assistantSessionId);
     if (!live) return;
+    // The conversation's thread record: its runs, their outcomes and follow-ups.
+    try { userContext?.onDispatch(live.record, payload); } catch {}
     if (!live.record.dispatchRunIds?.includes(run.runId)) { live.record.dispatchRunIds = [...(live.record.dispatchRunIds || []), run.runId].slice(-100); touch(live); }
     sendToSockets(live, { type: 'assistant:dispatch', reason: payload.reason, run });
     scheduleUsage(live.record.id);
@@ -2316,6 +2644,7 @@ export function createAssistantRuntime({
     if (!live) return;
     const removed = new Set((payload.runIds || []).map(String));
     if (!removed.size) return;
+    try { userContext?.onDispatch(live.record, { type: 'assistant:run-removed', runIds: [...removed] }); } catch {}
     for (const runId of removed) {
       live.obligations.delete(runId);
       live.nudgedRuns.delete(runId);
@@ -2351,15 +2680,25 @@ export function createAssistantRuntime({
    * `fallback`: the UI's start path — a disabled model starts on its enabled stand-in (reported back) instead of refusing.
    * `channel`: where the conversation happens ('whatsapp'); the persona adapts to it.
    * `internal.remote` ({ channel, level, strictWorkerApprovals, autonomousUntil, computerUse }): an in-process
-   * caller (the WhatsApp bridge) starts a remote session. REST callers pass only the body, so
+   * caller (the WhatsApp bridge) starts a remote session (`autonomousUntil` limits Autonomous on a channel
+   * other than WhatsApp only: on WhatsApp it has no time limit). REST callers pass only the body, so
    * they cannot. The record is flagged before it is persisted: after a restart without a new
    * registration the session reads as read-only.
    */
+  async function resolveAutoAccount(brain) {
+    if (brain.accountId !== 'auto' || !['claude-code', 'codex'].includes(brain.provider)) return brain;
+    await accountUsage?.refresh(brain.provider);
+    const rows = accountUsage?.list()?.[brain.provider] || [];
+    const key = brain.provider === 'codex' ? 'codexAccount' : 'claudeAccount';
+    const { row } = chooseUsageAccount(rows, 'auto', configStore?.workers?.()?.[key] || 'default');
+    if (!row) throw Object.assign(new Error('Auto requires a signed-in subscription account.'), { code: 'ACCOUNT_NO_SUBSCRIPTION', status: 409 });
+    return { ...brain, accountId: row.id };
+  }
   async function createSession({ brain = {}, label = null, cwd = null, windowId = null, fallback = false, channel = null } = {}, internal = {}) {
     const id = `assistant-${randomUUID()}`;
     const requested = normalizeBrain({ ...brain, cwd: brain?.cwd || cwd || settings.defaultBrain.cwd || PACKAGE_ROOT }, settings.defaultBrain, { catalog: catalog?.peek?.() || null });
     const enabled = await enabledBrain(requested, { fallback: fallback === true, named: !!brain?.model });
-    const normalized = enabled.brain;
+    const normalized = await resolveAutoAccount(enabled.brain);
     const record = {
       id, brain: normalized, title: label ? clip(label, 60) : DEFAULT_SESSION_TITLE, project: detectProject(normalized.cwd) || 'global',
       createdAt: iso(now()), updatedAt: iso(now()), lastActiveAt: null, status: 'idle', providerSessionId: null, providerThreadId: null,
@@ -2395,6 +2734,10 @@ export function createAssistantRuntime({
     if (mode && !normalized) { const error = new Error(`Unknown route mode ${mode}`); error.code = 'ROUTE_MODE_INVALID'; error.status = 400; throw error; }
     live.record.routing = { ...(live.record.routing || {}), mode: normalized };
   }
+  /** null, '' or an unknown value clears the session's own level: it reads as the default. */
+  function applyTestDensity(live, level) {
+    live.record.testDensity = normalizeTestDensity(level, null);
+  }
   function applyComputerUse(live, enabled) {
     // A remote session's computer use is not a per-conversation choice: the owner's switch and
     // the level decide (remoteComputerUse). A PATCH, the socket and updateSession change nothing.
@@ -2406,29 +2749,46 @@ export function createAssistantRuntime({
   async function updateSession(id, patch = {}) {
     const live = sessions.get(id);
     if (!live) return null;
-    if (patch.title) live.record.title = clip(patch.title, 60);
+    // A rename (tab, float header, sidepanel ✎) is the session's one name: every list reads it
+    // here, and `userRenamed` tells a host to reopen the session under it. Calling it "SynaBun"
+    // again gives the name up: the next prompt titles it, as for a session never renamed. The
+    // mark stays, as `false`: a host holding the old name with a saved tab must not write it back
+    // (no mark at all means a rename the record never heard of, which a host does write).
+    const renamed = typeof patch.title === 'string' ? clip(patch.title, 60) : '';
+    if (renamed && renamed !== DEFAULT_SESSION_TITLE) { live.record.title = renamed; live.record.userRenamed = true; }
+    else if (renamed && live.record.userRenamed) { live.record.title = DEFAULT_SESSION_TITLE; live.record.userRenamed = false; }
     if (patch.routing && typeof patch.routing === 'object' && 'mode' in patch.routing) applyRouteMode(live, patch.routing.mode);
     if ('computerUse' in patch) applyComputerUse(live, patch.computerUse);
+    if ('testDensity' in patch) applyTestDensity(live, patch.testDensity);
     if (patch.brain && typeof patch.brain === 'object') {
       // A provider switch that names no model starts from the new provider's
       // default, never from the old provider's model id.
       const switching = BRAIN_PROVIDERS.has(patch.brain.provider) && patch.brain.provider !== live.record.brain.provider;
       const base = switching && !patch.brain.model ? { ...live.record.brain, model: null } : live.record.brain;
       let next = normalizeBrain({ ...base, ...patch.brain, model: patch.brain.model || base.model }, base, { catalog: catalog?.peek?.() || null });
+      next = await resolveAutoAccount(next);
       const modelChanged = next.model !== live.record.brain.model || next.provider !== live.record.brain.provider;
       if (modelChanged) next = (await enabledBrain(next)).brain;
       // A remote session keeps what was asked for and runs what its level allows.
       if ('permissionMode' in patch.brain || 'planMode' in patch.brain) next = clampModeWrite(live, next);
       else next = clampedBrain(live, next);
-      const providerChanged = next.provider !== live.record.brain.provider || next.accountId !== live.record.brain.accountId || next.cwd !== live.record.brain.cwd || next.mcpProfile !== live.record.brain.mcpProfile;
+      const providerChanged = patch.restartBrain === true || next.provider !== live.record.brain.provider || next.accountId !== live.record.brain.accountId || next.cwd !== live.record.brain.cwd || next.mcpProfile !== live.record.brain.mcpProfile;
       // A usage limit is the account's: another provider or account starts without the notice.
       if (next.provider !== live.record.brain.provider || next.accountId !== live.record.brain.accountId) setLimit(live, null);
       live.record.brain = next;
-      live.record.project = detectProject(next.cwd) || live.record.project || 'global';
+      // The panel's brain names its working folder `project` and never sends `cwd`. A project picked
+      // there (the toolbar's Working project, the empty state's picker) moves the folder the way a
+      // prompt's cwd does (runTurn): a brain that is running keeps its conversation and gets the folder
+      // with its next turn; one not started yet starts there, with it as its Default project.
+      const folder = !patch.brain.cwd && typeof patch.brain.project === 'string' ? patch.brain.project.trim() : '';
+      if (folder && folder !== next.cwd) live.record.brain = { ...next, cwd: folder };
+      live.record.project = detectProject(live.record.brain.cwd) || live.record.project || 'global';
       if (providerChanged) {
         await disposeBrain(live, 'switched');
         live.record.providerSessionId = null;
         live.record.providerThreadId = null;
+        // Another conversation: its user-context digest is built (and frozen) anew.
+        try { userContext?.conversationReplaced(live.record); } catch {}
         if (live.record.usageState) delete live.record.usageState[next.provider === 'claude-code' ? 'claude' : next.provider];
         if (live.record.usageState) delete live.record.usageState.codexThreadId;
         live.record.status = 'idle';
@@ -2472,6 +2832,8 @@ export function createAssistantRuntime({
       live.record.status = 'ended';
       touch(live);
       persist({ force: true });
+      // The conversation's thread memory is written now (not awaited: an embedding and a write).
+      try { userContext?.sessionClosed(id); } catch {}
       broadcast('assistant:session-ended', live);
     } finally { closed(); }
     return view(live);
@@ -2489,6 +2851,7 @@ export function createAssistantRuntime({
       usageTimers.delete(id);
       usageSentAt.delete(id);
       metered('drop', () => usage?.dropSession?.(id));
+      try { userContext?.sessionDestroyed(id); } catch {}
       try { remotePolicy?.forgetSession?.(id); } catch {}
       try { rmSync(resolve(dataDir, 'assistant', id), { recursive: true, force: true }); } catch {}
       persist({ force: true });
@@ -2509,6 +2872,13 @@ export function createAssistantRuntime({
     }
     return null;
   }
+  // Why the Claude account a brain names cannot run now ('' when it can, or when that is not known yet).
+  function claudeAccountUnusable(accountId) {
+    try { return claudeAccounts?.unusableReason?.(accountId || 'default') || ''; } catch { return ''; }
+  }
+  function codexAccountUnusable(accountId) {
+    try { return codexAccounts?.unusableReason?.(accountId || 'default') || ''; } catch { return ''; }
+  }
   function accountInUse(provider, accountId) {
     for (const live of sessions.values()) {
       if (live.brain && live.record.brain?.provider === provider && (live.record.brain?.accountId || 'default') === accountId) return true;
@@ -2535,6 +2905,23 @@ export function createAssistantRuntime({
   }
   /** Something runs, or the approved plan's turn or a compact is waiting to (a prompt would be refused). */
   function isBusy(id) { const live = sessions.get(String(id || '')); return sessionBusy(live) || (!!live && !!workReserved(live)); }
+  /**
+   * The session whose live brain holds this credential (whatsapp_send_file's caller identity:
+   * BRAIN_CREDENTIAL_RE), or null. Only a well-formed value is compared, in constant time and
+   * against every live brain, so neither a match nor its position shows in the time taken.
+   */
+  function sessionForBrainCredential(value) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (!BRAIN_CREDENTIAL_RE.test(text)) return null;
+    const given = createHash('sha256').update(text).digest();
+    let found = null;
+    for (const [id, live] of sessions) {
+      if (!live.brain || typeof live.brainCredential !== 'string') continue;
+      const held = createHash('sha256').update(live.brainCredential).digest();
+      if (timingSafeEqual(given, held) && found === null) found = id;
+    }
+    return found;
+  }
   /** The session's remote policy (lib/remote-policy.js), or null. */
   function sessionPolicy(id) { const live = sessions.get(String(id || '')); return live ? remotePolicyFor(live) : null; }
   /** Where the session's conversation happens: 'whatsapp' (WhatsApp Link), or null for the panel. */
@@ -2752,6 +3139,8 @@ export function createAssistantRuntime({
     try { ws.send(JSON.stringify(engine)); } catch {}
     try { ws.send(JSON.stringify({ type: 'assistant:session', session: view(live), reason: 'attached' })); } catch {}
     if (usage) try { ws.send(JSON.stringify({ type: 'assistant:usage', ...usageView(live.record.id) })); } catch {}
+    // The session budget and its split as they are now.
+    try { const budgetNow = sessionMoney(live.record.id); if (budgetNow) ws.send(JSON.stringify({ type: 'assistant:budget', sessionId: live.record.id, reason: 'attached', budget: budgetNow })); } catch {}
     // The limit notice as it is now (null clears one this panel still shows from before).
     sendLimit(live, [ws]);
     const replay = live.buffer.splice(0, live.buffer.length);
@@ -2772,7 +3161,7 @@ export function createAssistantRuntime({
         // `request_id`: the panel's id for this prompt. A refusal reaches this socket
         // alone and carries it back, so this panel (only) puts the text back.
         const request = { id: msg.request_id ? String(msg.request_id) : null, reply };
-        const result = await runQuery(live, { text: msg.prompt, images: msg.images || [], cwd: msg.cwd || null, model: msg.model || null, effort: msg.effort || null, permissionMode: msg.permissionMode || null, planMode: typeof msg.planMode === 'boolean' ? msg.planMode : null, origin: 'ui', request });
+        const result = await runQuery(live, { text: msg.prompt, images: msg.images || [], cwd: msg.cwd || null, model: msg.model || null, effort: msg.effort || null, permissionMode: msg.permissionMode || null, planMode: typeof msg.planMode === 'boolean' ? msg.planMode : null, origin: 'ui', request, typed: typeof msg.typed === 'string' ? msg.typed : null, greetingId: typeof msg.greetingId === 'string' ? msg.greetingId : null });
         // Refused before it ran: the panel, "working" since it sent, shows what runs now.
         if (result && !result.ok && result.code !== 'TURN_FAILED') reply({ type: 'reattach_result', ok: true, sessionId: live.record.id, running: isBusy(live.record.id) });
         return;
@@ -2814,6 +3203,12 @@ export function createAssistantRuntime({
         broadcast('assistant:session-updated', live);
         sendToSockets(live, { type: 'assistant:session', session: view(live), reason: 'routing' });
         return;
+      case 'set_test_density':
+        applyTestDensity(live, msg.level);
+        touch(live);
+        broadcast('assistant:session-updated', live);
+        sendToSockets(live, { type: 'assistant:session', session: view(live), reason: 'tests' });
+        return;
       case 'set_computer_use':
         applyComputerUse(live, msg.enabled);
         touch(live);
@@ -2837,12 +3232,14 @@ export function createAssistantRuntime({
         return;
       case 'compact':
         live.record.memoryGeneration = (live.record.memoryGeneration || 1) + 1;
+        try { userContext?.onCompaction(live.record); } catch {}
         touch(live);
         // Session work: it starts once a running turn ends, and nothing else starts until it settles.
         queueWork(live, { kind: 'compact', reply });
         return;
       case 'clear':
         live.record.memoryGeneration = (live.record.memoryGeneration || 1) + 1;
+        try { userContext?.onCompaction(live.record); } catch {}
         touch(live);
         return;
       case 'heartbeat':
@@ -2869,6 +3266,8 @@ export function createAssistantRuntime({
           live.record.providerSessionId = msg.providerSessionId;
           // Another provider session: the meter's baseline was the old one's.
           if (moved) resetMeterIdentity(live, msg.providerSessionId);
+          // …and so was the frozen user-context digest.
+          if (moved) { try { userContext?.conversationReplaced(live.record); } catch {} }
           touch(live);
           await live.brain?.resume?.(msg.providerSessionId);
         }
@@ -2887,7 +3286,20 @@ export function createAssistantRuntime({
     }
   }
 
+  /** The dispatcher's reading of a session's Test density (wired in server.js); null for an unknown session. */
+  function testDensityFor(id) {
+    const live = sessions.get(id);
+    return live ? testDensityOf(live.record) : null;
+  }
+
   // ── router sinks (wired lazily in server.js; see assistant-router.js) ──────
+  /** What the budget planner needs of a session: its brain, project, and whether it is still open. */
+  function budgetSession(id) {
+    const live = sessions.get(String(id || ''));
+    if (!live) return null;
+    const brain = live.record.brain || {};
+    return { provider: brain.provider || null, model: brain.model || null, accountId: brain.accountId || null, project: live.record.project || null, open: live.record.status !== 'ended' };
+  }
   function routerSession(id) {
     const live = sessions.get(id);
     if (!live) return null;
@@ -2962,7 +3374,8 @@ export function createAssistantRuntime({
     const label = row?.label || target.model || 'the chosen model';
     const summary = route?.summary || '';
     const text = `[SynaBun Router] The user chose to run ${summary ? `"${summary}"` : 'this task'} here on ${label}${target.effort ? ` (effort ${target.effort})` : ''}. Continue that task now on this model, from where the conversation left off.`;
-    queueWork(live, { kind: 'continuation', gen, options: { text, turnModel: target.model || null, turnEffort: target.effort || null, gateOpen: true } });
+    // `origin`: where the prompt this task came from was written, so the continuation answers there.
+    queueWork(live, { kind: 'continuation', gen, options: { text, turnModel: target.model || null, turnEffort: target.effort || null, gateOpen: true, origin: lastPromptOrigin(live) } });
     return true;
   }
   function routerSinks() {
@@ -2989,6 +3402,19 @@ export function createAssistantRuntime({
     }
     return '';
   }
+  /**
+   * Where the last human prompt came from ('ui', 'whatsapp', 'api'): the transcript's after a restart
+   * (a prompt journaled without an origin was typed in the panel). null when there is none.
+   */
+  function lastPromptOrigin(live) {
+    if (live.lastPromptOrigin) return live.lastPromptOrigin;
+    const entries = readTranscript(live.record.id, 200);
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+      const event = entries[i]?.packet?.event;
+      if (event?.type === 'synabun.user_prompt') return event.origin ? String(event.origin) : 'ui';
+    }
+    return null;
+  }
   function clarifySession(id) {
     const live = sessions.get(id);
     if (!live) return null;
@@ -3204,7 +3630,7 @@ export function createAssistantRuntime({
               ? { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: 'Computer use is on for this WhatsApp turn.' } }
               : { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask', permissionDecisionReason: 'The user is asked once per task before the Mac is controlled from WhatsApp.' } };
           }
-          if (remoteLevel(live) === 'autonomous' || REMOTE_ASK_EXEMPT.has(tool)) return {};
+          if (remoteLevel(live) === 'autonomous' || REMOTE_ASK_EXEMPT.has(tool) || isReplyTool(tool)) return {};
           if (claudeReadOnlyPermission(tool, toolInput) !== 'deny') return {};
           return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask', permissionDecisionReason: `This session is driven from ${live.record.remote?.channel === 'whatsapp' || !live.record.remote?.channel ? 'WhatsApp' : live.record.remote.channel}: the user approves ${tool} first.` } };
         }],
@@ -3303,6 +3729,7 @@ export function createAssistantRuntime({
       live.record.status = 'idle';
     }
     persist({ force: true });
+    try { userContext?.shutdown(); } catch {}
     // Rows whose append failed get one more try before the process goes.
     metered('flush', () => usage?.flush?.());
   }
@@ -3326,12 +3753,14 @@ export function createAssistantRuntime({
     handleWebSocket, listSessions, getSession, createSession, updateSession, closeSession, destroySession,
     resolveTerminal, accountInUse, ownsIsolatedServe, noteDispatch, subscribe, shutdown,
     observeBroadcast: onPermissionBroadcast,
-    routerSession, routerSend, routerEvent, routerMailbox, routerContinue, routerSinks, routerRouted, routerRouteFailed, routerComputerApproved, gateCheck, isPlanning, isPlanReadOnly,
+    testDensityFor, routerSession, routerSend, routerEvent, routerMailbox, routerContinue, routerSinks, routerRouted, routerRouteFailed, routerComputerApproved, gateCheck, isPlanning, isPlanReadOnly,
     clarifySession, clarifyEvent, clarifyGate, clarifySinks,
     getComputerUse, getComputerTurn, supersedeComputerApproval, abortTurn, notifySession,
-    brainSpend, brainCapUsd, onBudgetChanged, currentTask, usageView,
+    brainSpend, brainSpendByProvider, budgetSession, onBudgetChanged, onBudgetSplit, sendBudget, currentTask, usageView,
     // Programmatic surface (the WhatsApp bridge) and remote sessions.
     observe, submit, stopTurn, answerControl, answerDispatchControl, pendingControls, isBusy, sessionPolicy, sessionChannel,
-    _internals: { sessions, ensureBrain, disposeBrain, runQuery, enqueueMailbox, deliverMailbox, settings, ensureGate, onBrainPacket, onTurnFinished, remoteHooks, packetObservers },
+    // whatsapp_send_file's caller identity (POST /api/assistant/whatsapp/send-file).
+    sessionForBrainCredential,
+    _internals: { sessions, ensureBrain, disposeBrain, runQuery, enqueueMailbox, deliverMailbox, settings, ensureGate, onBrainPacket, onTurnFinished, remoteHooks, packetObservers, userContext },
   };
 }