@tangleai/assistant 0.21.1

package/src/controller.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The assistant's impure effects: the streaming agent turn, the
+ * settings persistence, the transcript persistence and the ledger. The
+ * injected `aiFetch` keeps the whole thing testable against a scripted
+ * transport, and the injected `ledger` keeps it testable without a
+ * store.
+ * @param {{ toolbox: any, getApp: () => any,
+ *   aiFetch?: typeof fetch,
+ *   aiStorage: { read: () => any, write: (data: any) => any },
+ *   aiChat: { read: () => any, write: (data: any) => any },
+ *   ledger: any, system?: string, headers?: Record<string, string>, onDispose?: () => any }} deps
+ */
+export function createAssistantController(deps: {
+    toolbox: any;
+    getApp: () => any;
+    aiFetch?: typeof fetch;
+    aiStorage: {
+        read: () => any;
+        write: (data: any) => any;
+    };
+    aiChat: {
+        read: () => any;
+        write: (data: any) => any;
+    };
+    ledger: any;
+    system?: string;
+    headers?: Record<string, string>;
+    onDispose?: () => any;
+}): {
+    effects: {
+        [k: string]: (props: any, dispatch: any) => void | Promise<any>;
+    };
+    cancel: () => void;
+    dispose: () => any;
+    readonly signal: AbortSignal;
+};

package/src/controller.js

@@ -0,0 +1,322 @@
+//@ts-check
+import { createChatClient, probeProvider } from '@tangleai/models';
+import { createAgent, createRefiner } from '@tangleai/agents';
+import { createEnvironment } from '@tangleai/context';
+import { applyJSONPatch, compileJsonQuery } from '@jarenjs/json';
+import { isConfigured } from './settings.js';
+/** Chat turns sent back to the model per request (persisted transcripts can be long). */
+const HISTORY_WINDOW = 20;
+
+/** Chat turns kept in the persisted transcript (a localStorage slot, not an archive). */
+const SAVED_WINDOW = 100;
+
+/**
+ * How many memories the agent carries into a turn. Small on purpose:
+ * they are paid for out of the same history budget the conversation is,
+ * and a retrieval that crowded out the conversation would be a worse
+ * assistant with a better memory.
+ */
+const MEMORY_WINDOW = 5;
+
+/**
+ * The ledger as the panel shows it: the active objective (a superseded
+ * or abandoned one is not "what we are doing" and is not shown), what
+ * has been recorded against it, and how many dropped rounds are sitting
+ * in slots waiting for a `recall`. One read, so the panel can never
+ * disagree with itself about which turn it is describing.
+ * @param {any} ledger
+ */
+async function readLedger(ledger) {
+  const goal = await ledger.getGoal();
+  const slots = await ledger.listSlots();
+  return {
+    goal: goal !== null && goal.status === 'active'
+      ? { objective: goal.objective, progress: goal.progress, checkpoint: goal.checkpoint }
+      : null,
+    memories: (await ledger.listMemories()).length,
+    archived: slots.filter((slot) => slot.kind === 'agent-round').length,
+    persistence: ledger.storageStatus?.() ?? null,
+    retention: await ledger.retentionReport?.() ?? null,
+  };
+}
+
+/**
+ * The assistant's impure effects: the streaming agent turn, the
+ * settings persistence, the transcript persistence and the ledger. The
+ * injected `aiFetch` keeps the whole thing testable against a scripted
+ * transport, and the injected `ledger` keeps it testable without a
+ * store.
+ * @param {{ toolbox: any, getApp: () => any,
+ *   aiFetch?: typeof fetch,
+ *   aiStorage: { read: () => any, write: (data: any) => any },
+ *   aiChat: { read: () => any, write: (data: any) => any },
+ *   ledger: any, system?: string, headers?: Record<string, string>, onDispose?: () => any }} deps
+ */
+export function createAssistantController(deps) {
+  let disposed = false, epoch = 0, closing;
+  /** @type {AbortController|null} */
+  let turnAbort = null;
+  const lifetime = new AbortController();
+  const fetchImpl = deps.aiFetch ?? globalThis.fetch;
+  deps = { ...deps, aiFetch: (url, init = {}) => fetchImpl(url, { ...init,
+    signal: AbortSignal.any([lifetime.signal, ...(init.signal ? [init.signal] : [])]) }) };
+  function cancel() { epoch++; turnAbort?.abort(); turnAbort = null; }
+  function dispose() {
+    if (disposed) return closing;
+    disposed = true; cancel(); lifetime.abort();
+    closing = Promise.resolve().then(() => deps.onDispose?.());
+    return closing;
+  }
+  /**
+   * The last completed turn, kept here rather than in the state: it is
+   * the trajectory a refinement reads, it is large, and nothing renders
+   * it. State holds what the panel draws; this holds what the next
+   * action needs.
+   * @type {{ messages: any[], steps: any[] } | null}
+   */
+  let lastRun = null;
+
+  /** The client the current settings describe, or a dispatched failure. */
+  const clientFor = (state, dispatch) => {
+    const s = state.ai.settings;
+    try {
+      return createChatClient({
+        provider: s.provider,
+        baseUrl: s.baseUrl,
+        apiKey: s.apiKey,
+        model: s.model,
+        fetch: deps.aiFetch,
+        headers: deps.headers,
+      });
+    }
+    catch (err) {
+      dispatch('ai/failed', /** @type {Error} */ (err).message);
+      return null;
+    }
+  };
+
+  const rawEffects = {
+    'ai-send': (props, dispatch) => {
+      const app = deps.getApp();
+      const state = app.getState();
+      const draft = state.ai.draft.trim();
+      if (draft === '' || state.ai.status === 'streaming') return;
+      if (!isConfigured(state.ai.settings)) {
+        dispatch('ai/failed', 'Add a provider, model and (for OpenRouter) an API key in settings first.');
+        return;
+      }
+      const runEpoch = epoch;
+      dispatch('ai/user', draft);
+
+      const client = clientFor(state, dispatch);
+      if (client === null) return;
+
+      // weak local models are first-class: enough rounds to read an
+      // engine's { error } result, fetch an example and try again —
+      // and a studio flow (template → write → patch → repair → save)
+      // legitimately runs past a dozen rounds on a small model. The
+      // history budget keeps those long sessions inside a small local
+      // context window (~6k tokens), which is what makes the higher
+      // cap affordable.
+      //
+      // With the ledger under it, that budget stops destroying: every
+      // round it drops is archived to a slot first and the model can
+      // `recall` it back. The same ledger puts the objective and what
+      // has been learned into the prompt of every turn.
+      // and with an ENVIRONMENT over that same ledger, the archive stops
+      // being a list of addresses to fetch one at a time: `env_grep`
+      // scans every archived round for a pattern and answers with which
+      // slot matched and one line of context, so "what did we try
+      // earlier?" costs one call instead of one call per round. The
+      // corpus and the archive share a store on purpose — the same
+      // operations reach both.
+      const environment = createEnvironment({
+        ledger: deps.ledger,
+        compileQuery: compileJsonQuery,
+      });
+      const agent = createAgent({
+        client, toolbox: { toFunctionTools: () => deps.toolbox.toFunctionTools(),
+          execute: (name, args) => disposed || epoch !== runEpoch
+            ? { error: 'The assistant turn was cancelled.' } : deps.toolbox.execute(name, args) }, system: deps.system ?? 'Help the user complete their task using the available tools.', maxToolRounds: 16,
+        historyBudget: 24_000,
+        ledger: deps.ledger,
+        environment,
+        retrieval: { memories: { limit: MEMORY_WINDOW } },
+      });
+      // build the turn from this effect's own snapshot: the ai/user
+      // dispatch above is queued FIFO behind the running transaction,
+      // so a getState() here would still miss the draft
+      const history = [...state.ai.messages, { role: 'user', content: draft }]
+        .slice(-HISTORY_WINDOW)
+        .map((m) => ({ role: m.role, content: m.content }));
+      turnAbort?.abort(); turnAbort = new AbortController();
+      return agent.send(history, {
+        signal: turnAbort.signal,
+        onDelta: (text) => dispatch('ai/delta', text),
+        onReasoning: (text) => dispatch('ai/reasoning', text.length),
+        onToolCall: (call) => dispatch('ai/activity', call.name),
+        // back to 'Thinking…' between a tool's result and the next token
+        onToolResult: () => dispatch('ai/activity', null),
+      }).then(
+        // an empty final message is a model quirk worth an honest line —
+        // and a reasoning-only turn deserves to say what happened
+        (result) => {
+          if (disposed || epoch !== runEpoch) return;
+          lastRun = { messages: result.messages, steps: result.steps };
+          dispatch('ai/reply', result.message.content !== ''
+            ? result.message.content
+            : result.message.reasoning !== undefined
+              ? '*The model spent the whole turn reasoning without a final reply — send another message to continue.*'
+              : '*The model ended its turn without a reply — whatever it loaded is on screen; send another message to continue.*');
+          // the archive grows during a turn, so the panel's count is read
+          // after it: what the model can still reach is a fact about the
+          // finished turn, not the one that started it
+          readLedger(deps.ledger).then((view) => dispatch('ai/ledger', view), () => {});
+        },
+        (err) => dispatch('ai/failed', err?.message ?? String(err)),
+      );
+    },
+
+    // the ledger panel: one read, dispatched as one value. Run on open
+    // (so a reloaded page shows the objective it was left with) and
+    // after anything that writes.
+    'ai-ledger-read': (props, dispatch) => {
+      readLedger(deps.ledger).then((view) => dispatch('ai/ledger', view),
+        (err) => dispatch('ai/failed', err?.message ?? String(err)));
+    },
+
+    // clearing the conversation clears what compaction archived FROM it:
+    // an archived round is a piece of a transcript, and its address only
+    // ever appeared in that transcript's synopsis. Keeping the rounds
+    // would leave the panel counting recoverable context for a
+    // conversation that no longer exists — and leave bytes in the store
+    // that nothing can ever name again. Memories and the goal survive:
+    // they are what was LEARNED, not what was said.
+    'ai-clear-archive': (props, dispatch) => {
+      (typeof deps.ledger.clearArchives === 'function' ? deps.ledger.clearArchives()
+        : deps.ledger.listSlots().then((slots) => Promise.all(slots
+          .filter((slot) => slot.kind === 'agent-round' || slot.kind === 'agent-round-index')
+          .map((slot) => deps.ledger.deleteSlot(slot.name)))))
+        .then(() => readLedger(deps.ledger))
+        .then((view) => dispatch('ai/ledger', view),
+          (err) => dispatch('ai/failed', err?.message ?? String(err)));
+    },
+
+    'ai-goal-set': (props, dispatch) => {
+      const objective = deps.getApp().getState().ai.goalDraft.trim();
+      if (objective === '') return;
+      deps.ledger.setGoal({ objective }).then((goal) => {
+        if (goal?.error !== undefined) {
+          dispatch('ai/failed', goal.error);
+          return;
+        }
+        // the draft is cleared by what comes back from the ledger, not by
+        // the action: the objective on screen is the stored one
+        return readLedger(deps.ledger).then((view) => dispatch('ai/goal-committed', view));
+      }, (err) => dispatch('ai/failed', err?.message ?? String(err)));
+    },
+
+    // "clear" abandons the objective rather than deleting it: the ledger
+    // keeps what this agent was asked to do, and the panel stops showing
+    // an objective nobody is working on
+    'ai-goal-clear': (props, dispatch) => {
+      deps.ledger.setGoalStatus('abandoned')
+        .then(() => readLedger(deps.ledger))
+        .then((view) => dispatch('ai/ledger', view),
+          (err) => dispatch('ai/failed', err?.message ?? String(err)));
+    },
+
+    // the refinement button: the model proposes an RFC 6902 patch over
+    // its own supplemental state, every stage of the gate runs, and what
+    // survives is committed. The patch engine is INJECTED here, exactly
+    // as @tangleai/agents requires — the package never imports @jarenjs/json.
+    'ai-remember': (props, dispatch) => {
+      const state = deps.getApp().getState();
+      if (lastRun === null) {
+        dispatch('ai/remembered', { note: 'Nothing to remember yet — send a message first.' });
+        return;
+      }
+      if (!isConfigured(state.ai.settings)) {
+        dispatch('ai/remembered', { note: 'Add a provider, model and key in settings first.' });
+        return;
+      }
+      const client = clientFor(state, dispatch);
+      if (client === null) return;
+      return createRefiner({
+        client,
+        ledger: deps.ledger,
+        applyPatch: (document, patch) => applyJSONPatch(document, patch),
+      }).refine(lastRun, { signal: lifetime.signal }).then((outcome) => {
+        const written = outcome.ok === true
+          ? outcome.memories.length + outcome.skills.length + outcome.progress.length
+          : 0;
+        dispatch('ai/remembered', {
+          note: outcome.ok !== true
+            ? `Nothing was stored — ${outcome.error}`
+            : written === 0
+              ? 'The assistant found nothing worth remembering from this session.'
+              : `Remembered ${written} evidenced item${written === 1 ? '' : 's'}.`,
+        });
+        return readLedger(deps.ledger).then((view) => dispatch('ai/ledger', view));
+      }, (err) => dispatch('ai/remembered', { note: err?.message ?? String(err) }));
+    },
+
+    'ai-save-settings': async (_props, dispatch) => {
+      try {
+        if (await deps.aiStorage.write(deps.getApp().getState().ai.settings) === false)
+          throw new Error('Assistant settings could not be saved.');
+      }
+      catch (error) { dispatch('ai/settings-open', true); dispatch('ai/failed', error.message); }
+    },
+
+    // the settings "Test connection" button: one /models probe with the
+    // exact auth a chat turn would use; the result object drives the
+    // status line and the model-name datalist
+    'ai-probe': (props, dispatch) => {
+      const s = deps.getApp().getState().ai.settings;
+      return probeProvider({
+        provider: s.provider,
+        baseUrl: s.baseUrl,
+        apiKey: s.apiKey,
+        fetch: deps.aiFetch,
+      }).then((result) => dispatch('ai/probe-result', result.ok
+        ? {
+          status: 'ok',
+          detail: `Connected — ${result.models.length} model${result.models.length === 1 ? '' : 's'} available.`,
+          models: result.models.slice(0, 100),
+        }
+        : { status: 'fail', detail: result.error, models: [] }));
+    },
+
+    // opening the panel unconfigured lands you in settings — pinned
+    // open, so the form does not hide the moment typing a model name
+    // makes the configuration valid (only Save closes and persists it)
+    'ai-ensure-settings': (props, dispatch) => {
+      const state = deps.getApp().getState();
+      if (state.ai.open && !isConfigured(state.ai.settings)) {
+        dispatch('ai/settings-open', true);
+      }
+    },
+
+    // the transcript mirror: every appended turn (and a clear) writes
+    // the visible messages through the injected store, so a reload
+    // resumes the conversation
+    'ai-persist': async (_props, dispatch) => {
+      const messages = deps.getApp().getState().ai.messages;
+      try {
+        if (await deps.aiChat.write({ messages: messages.slice(-SAVED_WINDOW) }) === false)
+          throw new Error('The assistant transcript could not be saved.');
+      }
+      catch (error) { dispatch('ai/failed', error.message); }
+    },
+  };
+  const effects = Object.fromEntries(Object.entries(rawEffects).map(([name, effect]) => [name, (props, dispatch) => {
+    if (disposed) return;
+    const version = epoch;
+    const publish = (action, payload) => { if (!disposed && version === epoch) dispatch(action, payload); };
+    return effect(props, publish);
+  }]));
+  effects['ai-cancel'] = () => { if (!disposed) cancel(); };
+  effects['ai-clear-run'] = () => { if (!disposed) { cancel(); lastRun = null; } };
+  return { effects, cancel, dispose, get signal() { return turnAbort?.signal ?? lifetime.signal; } };
+}

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export { ASSISTANT_ACTIONS } from "./actions.js";
+export { createAssistantController } from "./controller.js";
+export { DEFAULT_AI_SETTINGS, createAssistantState } from "./state.js";
+export { PROVIDER_OPTIONS, isConfigured } from "./settings.js";

package/src/index.js

@@ -0,0 +1,4 @@
+export { ASSISTANT_ACTIONS } from './actions.js';
+export { DEFAULT_AI_SETTINGS, createAssistantState } from './state.js';
+export { PROVIDER_OPTIONS, isConfigured } from './settings.js';
+export { createAssistantController } from './controller.js';

package/src/settings.d.ts

@@ -0,0 +1,6 @@
+export function isConfigured(s: any): boolean;
+export const PROVIDER_OPTIONS: {
+    value: string;
+    label: string;
+    local: boolean;
+}[];

package/src/settings.js

@@ -0,0 +1,11 @@
+//@ts-check
+import { PROVIDERS } from '@tangleai/models/providers';
+export const PROVIDER_OPTIONS = Object.entries(PROVIDERS)
+  .map(([value, preset]) => ({ value, label: preset.label, local: preset.local }));
+
+export function isConfigured(s) {
+  if (s.model.trim() === '') return false;
+  if (s.provider === 'custom') return s.baseUrl.trim() !== '';
+  if (s.provider === 'openrouter') return s.apiKey.trim() !== '';
+  return true; // local runtimes (Ollama, LM Studio) need no key
+}

package/src/state.d.ts

@@ -0,0 +1,32 @@
+/** @param {any} [aiSettings] @param {any} [aiChat] */
+export function createAssistantState(aiSettings?: any, aiChat?: any): {
+    open: boolean;
+    settingsOpen: boolean;
+    probe: {
+        status: string;
+        detail: any;
+        models: any[];
+    };
+    reasoningChars: number;
+    settings: any;
+    messages: any;
+    draft: string;
+    pending: string;
+    status: string;
+    activity: any;
+    error: any;
+    goal: any;
+    goalDraft: string;
+    memories: number;
+    persistence: any;
+    retention: any;
+    archived: number;
+    remembering: boolean;
+    remembered: any;
+};
+export namespace DEFAULT_AI_SETTINGS {
+    let provider: string;
+    let baseUrl: string;
+    let model: string;
+    let apiKey: string;
+}

package/src/state.js

@@ -0,0 +1,40 @@
+//@ts-check
+export const DEFAULT_AI_SETTINGS = {
+  provider: 'openrouter',  // 'openrouter' | 'ollama' | 'lmstudio' | 'custom'
+  baseUrl: '',             // required for 'custom'; overrides the preset otherwise
+  model: '',               // e.g. 'qwen/qwen3-4b' or a local model name
+  apiKey: '',              // bring your own; local runtimes need none
+};
+/** @param {any} [aiSettings] @param {any} [aiChat] */
+export function createAssistantState(aiSettings = null, aiChat = null) {
+ return {
+      open: false,
+      settingsOpen: false,
+      // the settings "Test connection" probe: idle | busy | ok | fail,
+      // a human detail line, and the model ids a successful probe found
+      probe: { status: 'idle', detail: null, models: [] },
+      // reasoning characters streamed this turn (thinking models emit
+      // reasoning before - or instead of - visible content)
+      reasoningChars: 0,
+      settings: { ...DEFAULT_AI_SETTINGS, ...(aiSettings ?? {}) },
+      // visible transcript: { role, content }; restored from local
+      // storage so a page reload keeps the conversation
+      messages: Array.isArray(aiChat?.messages) ? structuredClone(aiChat.messages) : [],
+      draft: '',             // composer text
+      pending: '',           // the assistant reply currently streaming
+      status: 'idle',        // 'idle' | 'streaming' | 'error'
+      activity: null,        // the tool the model is currently calling
+      error: null,
+      // the @tangleai/context ledger, as the panel shows it. Read from the
+      // ledger (not mirrored into it): the objective is durable state and
+      // this slice is a view of it, so a reload shows what storage holds
+      // rather than what this tab last typed.
+      goal: null,            // { objective, progress: [ { at, note, evidence } ] }
+      goalDraft: '',         // the objective composer
+      memories: 0,           // evidenced facts carried into every turn
+      persistence: null, retention: null,
+      archived: 0,           // dropped rounds sitting in slots, recallable
+      remembering: false,    // a refinement is in flight
+      remembered: null,      // what the last refinement did, in one line
+    };
+}

package/src/viewmodel.d.ts

@@ -0,0 +1,55 @@
+/** @param {any} ai @param {(source: string) => any} renderMarkdown */
+export function assistantView(ai: any, renderMarkdown: (source: string) => any): {
+    open: any;
+    status: any;
+    activity: any;
+    error: any;
+    draft: any;
+    configured: boolean;
+    showSettings: any;
+    settings: {
+        provider: any;
+        baseUrl: any;
+        model: any;
+        apiKey: any;
+        needsKey: boolean;
+        probe: {
+            status: any;
+            detail: any;
+            busy: boolean;
+            ok: boolean;
+            fail: boolean;
+            models: any;
+        };
+    };
+    providers: {
+        selected: boolean;
+        value: string;
+        label: string;
+        local: boolean;
+    }[];
+    empty: boolean;
+    messages: any;
+    streaming: boolean;
+    pending: any;
+    thinkingLabel: string;
+    goal: {
+        objective: any;
+        entries: any;
+        checkpointLabel: string;
+        progress: {
+            note: any;
+            evidence: any;
+        }[];
+        more: number;
+    };
+    goalDraft: any;
+    memories: any;
+    memoryLabel: string;
+    persistenceLabel: string;
+    retentionLabel: string;
+    archived: any;
+    archivedLabel: string;
+    remembering: any;
+    remembered: any;
+};

package/src/viewmodel.js

@@ -0,0 +1,77 @@
+//@ts-check
+import { PROVIDER_OPTIONS, isConfigured } from './settings.js';
+/** @param {any} ai @param {(source: string) => any} renderMarkdown */
+export function assistantView(ai, renderMarkdown) {
+  const s = ai.settings;
+  const configured = isConfigured(s);
+  return {
+    open: ai.open,
+    status: ai.status,
+    activity: ai.activity,
+    error: ai.error,
+    draft: ai.draft,
+    configured,
+    // the settings form shows until the assistant can actually run, or
+    // whenever the user opens it explicitly
+    showSettings: ai.settingsOpen || !configured,
+    settings: {
+      provider: s.provider,
+      baseUrl: s.baseUrl,
+      model: s.model,
+      apiKey: s.apiKey,
+      needsKey: s.provider === 'openrouter' || s.provider === 'custom',
+      probe: {
+        status: ai.probe.status,
+        detail: ai.probe.detail,
+        busy: ai.probe.status === 'busy',
+        ok: ai.probe.status === 'ok',
+        fail: ai.probe.status === 'fail',
+        models: ai.probe.models.map((id) => ({ id })),
+      },
+    },
+    providers: PROVIDER_OPTIONS.map((p) => ({ ...p, selected: p.value === s.provider })),
+    empty: ai.messages.length === 0,
+    messages: ai.messages.map((m) => (m.role === 'user'
+      ? { role: 'user', text: m.content }
+      : { role: 'assistant', article: renderMarkdown(m.content) })),
+    // the reply currently streaming in (plain text: it changes per token)
+    streaming: ai.status === 'streaming',
+    pending: ai.pending,
+    // the quiet-phase label: reasoning models think before they speak,
+    // and watching the thinking grow beats a blind spinner
+    thinkingLabel: ai.reasoningChars > 0
+      ? `Thinking… (${ai.reasoningChars} characters of reasoning)`
+      : 'Thinking…',
+    // the ledger: a persistent objective, what has been recorded against
+    // it, and what a compacted session can still reach. Every number here
+    // is derived from the ledger read, so the panel cannot claim a
+    // memory the store does not hold.
+    goal: ai.goal === null ? null : {
+      objective: ai.goal.objective,
+      entries: ai.goal.progress.length + (ai.goal.checkpoint?.sources.length ?? 0),
+      checkpointLabel: ai.goal.checkpoint ? `${ai.goal.checkpoint.sources.length} earlier progress entries retained with their evidence.` : '',
+      // newest first: the last thing that happened is the thing a reader
+      // wants, and the whole log would push the conversation off screen
+      progress: [...ai.goal.progress].reverse().slice(0, PROGRESS_SHOWN)
+        .map((entry) => ({ note: entry.note, evidence: entry.evidence })),
+      more: Math.max(0, ai.goal.progress.length - PROGRESS_SHOWN),
+    },
+    goalDraft: ai.goalDraft,
+    memories: ai.memories,
+    memoryLabel: `${ai.memories} remembered fact${ai.memories === 1 ? '' : 's'}`,
+    persistenceLabel: ai.persistence?.error ? `Storage failed: ${ai.persistence.error}`
+      : ai.persistence?.concurrency === 'single-writer' ? 'Use one tab at a time to update remembered state.' : '',
+    retentionLabel: ai.retention?.evicted?.length
+      ? `${ai.retention.evicted.length} earlier archive address(es) evicted under the storage budget.` : '',
+    archived: ai.archived,
+    // said in full sentences, because "12" beside a chat is not
+    // information: a compacted session has to LOOK recoverable
+    archivedLabel: `${ai.archived} earlier round${ai.archived === 1 ? '' : 's'} archived —`
+      + ' the assistant can fetch any of them back with recall.',
+    remembering: ai.remembering,
+    remembered: ai.remembered,
+  };
+}
+
+/** Progress entries the panel shows before it says "and N more". */
+const PROGRESS_SHOWN = 3;