@genesislcap/ai-assistant 15.19.6 → 15.20.0

package/sandbox/README.md

@@ -28,10 +28,11 @@ The panel covers, roughly in the order you'll want them:
 | **Composer** | `acceptedFiles` (the paperclip), attachment + rejected-file chips, the resize handle, `hideComposer`, `hideStopButton`, the placeholder |
 | **Agent picker & pinning** | `picker.mode`, how many agents exist, whether they opt in to manual selection, pin colours; a button to open the picker panel |
 | **Session menu (⋮)** | Whether a persistence provider is configured (the menu is gated on one) and `showSessionMenu`; a button to open the menu |
+| **Context window** | **Jump to state** (the four gate states in one click), the simulated window and fill, `chatConfig.context`, a flow-in-progress toggle, live readouts of the gate / thresholds / compaction plan, and Compact |
 | **Simulated state** | Forces `idle` / busy / cancelling / blocked / compacting / restoring onto the element |
-| **Transcript** | Seeds an empty, short, tool-and-markdown-heavy, or 28-turn conversation |
+| **Transcript** | Seeds an empty, short, tool-and-markdown-heavy, 28-turn, ~20k-token, or ~22k-token tool-loop conversation |
 | **Chrome** | Header title, popout mode, suggestions, the tool-call / reasoning / narration toggles, animations |
-| **Stage** | Frame size, light/dark, remount, full reset |
+| **Stage** | Frame size (floored at 400px — see below), light/dark, remount, full reset |
 
 Panel state persists in `localStorage`, so a reload picks up where you left off. **Reset sandbox**
 clears it.
@@ -44,8 +45,93 @@ composer all behave as they do against a live model. It also answers the orchest
 classifier call, round-robining across the configured agents so agent switching — and the
 "Switched to X" divider — actually happens.
 
-It is not a model. It ignores the system prompt, never calls a tool, and `prompt()` (suggestions,
-summarisation) returns nothing — so **Compact** runs but produces no summary.
+It is not a model. It ignores the system prompt and never calls a tool. It *does* answer the
+compaction summariser, so **Compact** works end to end — the reply is canned, but the plan, the
+splice, the divider and the shrunken context are all real. Suggestions still get nothing.
+
+## Checking the context gate (GENC-1567)
+
+The gate warns as the window fills and blocks sending before it overflows. Two things make it
+awkward to exercise honestly, and the panel works around both:
+
+- **Nothing reports usage.** The stub returns no `inputTokens`, so `contextTokens` would never be
+  set and the gate would sit inert forever. **Fill from** decides how it is faked. `Transcript
+  (measured)` — the default — runs the component's own estimator over the seeded conversation, so
+  the gate and the compaction planner are looking at the same thing. `Manual %` forces a
+  percentage, and `Unset` leaves it undefined, which is the real state on a provider that reports
+  no usage and where the gate must stay quiet rather than guess.
+
+  A manual fill can **disagree with the transcript**, and that is worth understanding rather than
+  avoiding: claim 85% of the window while the transcript holds 250 tokens and the gate says "full"
+  while the planner correctly reports nothing worth compacting — so the blocked copy offers a new
+  chat instead of Compact. The component is right about an impossible situation. The **Transcript**
+  readout flags the mismatch so it is visible rather than mystifying.
+- **A real window is too big to fill by hand.** At 200k the block sits at 175k, and a transcript
+  that large makes the page miserable to work in. **Window (tokens)** shrinks it. It is written to
+  the stub provider as well as the element, because the element re-resolves its limit from the
+  active provider and would otherwise silently revert a value poked straight onto it.
+
+The three readouts are the actual check. Every figure in them is read back **off the element** —
+`contextGate`, `contextBudget`, `compactionPlan`, `compactHint` — rather than recomputed by the
+panel, which would only ever confirm the panel agrees with itself.
+
+### Jump to state
+
+The fastest way in. **Jump to state** sets the whole group below to land on one of four:
+
+| | What you get |
+| --- | --- |
+| **Normal** | Plenty of room. No label, no outline. |
+| **Warning** | Amber pill reading "Approaching context limit", amber composer outline, sending still works. |
+| **Blocked — compacting will clear it** | Red pill reading "At context limit", red outline, composer disabled, and the placeholder offers **Compact**. |
+| **Blocked — compacting will NOT clear it** | The same red treatment, but the placeholder offers a **new chat** instead. |
+
+The last two are the pair worth understanding, because the difference is not visible in the panel:
+it is whether a compaction would reclaim enough to be worth offering. The compactable one seeds a
+long tool loop, which has cuttable boundaries all through it. The stuck one seeds a single tool
+result larger than any tail budget — a cut cannot split a message, so no boundary anywhere shrinks
+it, and the component correctly stops recommending Compact. One oversized file read does this in a
+real conversation.
+
+Each preset drives the ordinary controls rather than forcing the element, so what you land on is
+the component deciding for itself. Move anything by hand afterwards and the dropdown drops to
+**Custom** — it is a shortcut, not a readout, and the **Gate** line is what tells you where you
+actually are.
+
+### The rest of the panel
+
+A run worth doing:
+
+1. Seed **Tool loop**. One user turn, then 24 tool-call/result pairs and no user message anywhere
+   inside — the shape the old compaction rule could not touch at all, because it could only cut at
+   a user boundary and there was none to cut at. The plan readout should show a real reclaim with
+   the cut landing inside the loop (around message 23 of 50, at the defaults).
+2. On the default **Transcript (measured)** fill, that seed alone lands you at the block — no
+   slider needed. The ⋮ pill grows an amber "Approaching context limit" label at the warning and a
+   red "At context limit" at the block, the composer picks up a matching outline from the warning
+   onwards, and at the block it disables with the full explanation in its placeholder. Seed
+   **Huge** for the warning state and **Tools, markdown, agent switch** to drop back to clear.
+3. Turn **`showSessionMenu`** off (or the persistence provider), still past the warning. The gate
+   forces ⋮ back on screen — and the menu shows **Compact only**, no Clear.
+4. Turn **Flow in progress** on at a blocking fill. The block downgrades to a warning and sending
+   works again: a flow always gets to finish.
+5. Hit **Compact**. Watch the transcript collapse to a divider plus the tail, and the readouts drop
+   back under the warning line.
+
+**Thresholds** also shows `abort`, the point at which a *running* turn is stopped mid-loop. It sits
+far above `block` on purpose: the reserve exists so an accepted turn can spend it, and a guard at
+the block line would kill every turn that used the headroom it was given.
+
+## 400px is the narrowest supported width
+
+The stage will not go below it — slider, drag handle and a restored panel state are all clamped —
+because the assistant is not built narrower than that. The blocked-state placeholder is the case
+that pins it: it carries two sentences, and the height floor that stops them being clipped is sized
+from measurement at 400px. Narrower, the message wraps further and clips again.
+
+If you need to know the real requirement at some width, measure it rather than eyeballing a
+screenshot — `scrollHeight > clientHeight` on the inner `textarea`. A line that is 8px short looks
+complete.
 
 ## Things worth knowing
 
@@ -59,6 +145,9 @@ summarisation) returns nothing — so **Compact** runs but produces no summary.
   seed simply re-applies. **Reset sandbox** clears both.
 - **"Simulated state" is a blunt instrument.** It writes `state` / `blocked` / `compacting` /
   `restoring` straight onto the element. A real send will move `state` again underneath it.
+- **Compact is correctly a no-op on a small transcript.** Compaction is sized in tokens now, so ten
+  short turns are not worth a summariser call and the button stays greyed out. The plan readout says
+  why. Seed **Tool loop** or **Huge** to give it something to do.
 - **The panel is deliberately plain HTML.** It has to stay usable while the design-system components
   it would otherwise be built from are the ones being edited, and it sits outside the design system
   provider so a theme change on the stage can't restyle it.

package/sandbox/controls.ts

@@ -15,6 +15,8 @@ export type ControlDef<S> =
       label: string;
       options: ReadonlyArray<{ value: string; label: string }>;
       hint?: string;
+      /** Lifts the row out of the list — for the one control a group is really about. */
+      featured?: boolean;
     }
   | { kind: 'text'; key: keyof S & string; label: string; placeholder?: string; hint?: string }
   | {
@@ -26,7 +28,14 @@ export type ControlDef<S> =
       step?: number;
       hint?: string;
     }
-  | { kind: 'action'; label: string; run: () => void; hint?: string };
+  | { kind: 'action'; label: string; run: () => void; hint?: string }
+  /**
+   * A read-only line whose text is recomputed on demand rather than bound to
+   * state — for showing what the component DERIVED, which is the only way to
+   * check a derivation by hand. `renderControls` returns a refresh function; call
+   * it after applying state.
+   */
+  | { kind: 'readout'; label: string; render: () => string; hint?: string };
 
 export interface ControlGroup<S> {
   title: string;
@@ -61,16 +70,31 @@ const withHint = (row: HTMLElement, hint?: string): HTMLElement => {
 
 /**
  * Renders `groups` into `host`, reading from and writing to `state`. `onChange`
- * fires after every edit with the mutated state — the caller re-applies it to
- * the assistant.
+ * fires after every edit with the mutated state and the key that changed — the
+ * caller re-applies it to the assistant.
+ *
+ * Returns a `refresh()` that re-reads every control's value back out of `state`
+ * and recomputes the readouts. That is what lets one control REWRITE others (a
+ * preset, say) without rebuilding the panel: a rebuild drops focus mid-drag and
+ * collapses any group the user had open.
  */
 export function renderControls<S extends Record<string, any>>(
   host: HTMLElement,
   groups: ReadonlyArray<ControlGroup<S>>,
   state: S,
-  onChange: (state: S) => void,
-): void {
+  onChange: (state: S, key?: keyof S & string) => void,
+): () => void {
   host.textContent = '';
+  const refreshers: Array<() => void> = [];
+
+  /**
+   * Push `state` back into a control, unless the user is currently interacting
+   * with it — re-writing the value of a range being dragged fights the drag.
+   */
+  const syncing = (node: HTMLElement, write: () => void) => () => {
+    if (document.activeElement === node) return;
+    write();
+  };
 
   for (const group of groups) {
     const details = el('details', 'group');
@@ -91,7 +115,25 @@ export function renderControls<S extends Record<string, any>>(
         continue;
       }
 
-      const row = el('label', `row row-${control.kind}`);
+      if (control.kind === 'readout') {
+        const row = el('div', 'row row-readout');
+        const name = el('span', 'label');
+        name.textContent = control.label;
+        const value = el('output', 'readout-value');
+        const refresh = () => {
+          value.textContent = control.render();
+        };
+        refresh();
+        refreshers.push(refresh);
+        row.append(name, value);
+        details.appendChild(withHint(row, control.hint));
+        continue;
+      }
+
+      const row = el(
+        'label',
+        `row row-${control.kind}${'featured' in control && control.featured ? ' row-featured' : ''}`,
+      );
       const name = el('span', 'label');
       name.textContent = control.label;
 
@@ -101,8 +143,13 @@ export function renderControls<S extends Record<string, any>>(
         input.checked = Boolean(state[control.key]);
         input.addEventListener('change', () => {
           (state as any)[control.key] = input.checked;
-          onChange(state);
+          onChange(state, control.key);
         });
+        refreshers.push(
+          syncing(input, () => {
+            input.checked = Boolean(state[control.key]);
+          }),
+        );
         row.append(input, name);
       } else if (control.kind === 'select') {
         const select = el('select');
@@ -115,8 +162,13 @@ export function renderControls<S extends Record<string, any>>(
         select.value = String(state[control.key]);
         select.addEventListener('change', () => {
           (state as any)[control.key] = select.value;
-          onChange(state);
+          onChange(state, control.key);
         });
+        refreshers.push(
+          syncing(select, () => {
+            select.value = String(state[control.key]);
+          }),
+        );
         row.append(name, select);
       } else if (control.kind === 'text') {
         const input = el('input');
@@ -125,8 +177,13 @@ export function renderControls<S extends Record<string, any>>(
         input.value = String(state[control.key] ?? '');
         input.addEventListener('input', () => {
           (state as any)[control.key] = input.value;
-          onChange(state);
+          onChange(state, control.key);
         });
+        refreshers.push(
+          syncing(input, () => {
+            input.value = String(state[control.key] ?? '');
+          }),
+        );
         row.append(name, input);
       } else {
         const input = el('input');
@@ -140,8 +197,14 @@ export function renderControls<S extends Record<string, any>>(
         input.addEventListener('input', () => {
           readout.textContent = input.value;
           (state as any)[control.key] = Number(input.value);
-          onChange(state);
+          onChange(state, control.key);
         });
+        refreshers.push(
+          syncing(input, () => {
+            input.value = String(state[control.key] ?? control.min);
+            readout.textContent = input.value;
+          }),
+        );
         name.appendChild(readout);
         row.append(name, input);
       }
@@ -151,4 +214,8 @@ export function renderControls<S extends Record<string, any>>(
 
     host.appendChild(details);
   }
+
+  return () => {
+    for (const refresh of refreshers) refresh();
+  };
 }

package/sandbox/fixtures.ts

@@ -206,11 +206,128 @@ const LONG: ChatMessage[] = stamped(
   ]).flat(),
 );
 
+/**
+ * The same chars-per-token approximation the estimator falls back to, so a
+ * fixture asking for N tokens lands near N on the component's own reckoning.
+ */
+const APPROX_CHARS_PER_TOKEN = 4;
+
+/** Default window the stub reports, matching a mid-size production model. */
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+
+/**
+ * A paragraph of filler sized in tokens. Prose rather than repeated characters
+ * so the transcript stays readable while you scroll it.
+ */
+const bulk = (tokens: number): string => {
+  const sentence =
+    'The position was reconciled against the custodian file and the residual break was ' +
+    'allocated to the rates book before the cutoff, with the remainder carried forward. ';
+  return sentence.repeat(
+    Math.max(1, Math.ceil((tokens * APPROX_CHARS_PER_TOKEN) / sentence.length)),
+  );
+};
+
+/**
+ * A transcript large enough to actually be worth compacting (GENC-1567).
+ *
+ * `long` is 28 turns but only a few hundred tokens, and since compaction became
+ * token-driven that is correctly NOT worth a summariser call — so it can no
+ * longer demonstrate Compact. This one carries real weight per turn.
+ */
+const HUGE_TURNS = 16;
+const HUGE_TOKENS_PER_TURN = 1_200;
+
+const HUGE: ChatMessage[] = stamped(
+  Array.from({ length: HUGE_TURNS }, (_, i) => [
+    user(`Walk me through the breaks on book ${i + 1} in detail.`),
+    assistant(`Book ${i + 1}. ${bulk(HUGE_TOKENS_PER_TURN)}`, 'Positions'),
+  ]).flat(),
+);
+
+/**
+ * One user turn followed by a long agentic tool loop — the shape GENC-1567 was
+ * written for, and the one to reach for when checking the cut.
+ *
+ * There is no `user` message anywhere inside the loop, which is exactly why the
+ * old cut rule could not touch it: cutting only at a user boundary meant the
+ * whole loop was one indivisible block, so compaction reclaimed nothing however
+ * large it grew. Seed this, watch the plan report a real reclaim, and Compact —
+ * the summary should land with the loop behind it rather than in front.
+ */
+const LOOP_ITERATIONS = 24;
+const LOOP_RESULT_TOKENS = 900;
+
+const LOOP: ChatMessage[] = stamped([
+  user('Reconcile every book for yesterday and tell me what broke.'),
+  ...Array.from({ length: LOOP_ITERATIONS }, (_, i) => [
+    {
+      role: 'assistant' as const,
+      content: '',
+      agentName: 'Reconciliation',
+      toolCalls: [
+        {
+          id: `loop_${i}`,
+          name: 'reconcile_book',
+          args: { book: `BOOK-${i + 1}`, asOf: '2026-08-25' },
+        },
+      ],
+    },
+    {
+      role: 'tool' as const,
+      content: '',
+      agentName: 'Reconciliation',
+      toolResult: {
+        toolCallId: `loop_${i}`,
+        content: `BOOK-${i + 1} reconciliation detail. ${bulk(LOOP_RESULT_TOKENS)}`,
+      },
+    },
+  ]).flat(),
+  assistant('All books reconciled. Three had breaks worth reporting.', 'Reconciliation'),
+]);
+
+/**
+ * Over the limit and genuinely **uncompactable** — the case where the gate has to
+ * admit compaction is not the answer (GENC-1567).
+ *
+ * One user turn and a single tool result far larger than any tail budget. A cut
+ * cannot split a message, so there is no boundary anywhere that shrinks this:
+ * `findCompactionCut` walks back from the end, cannot fit even the one tool
+ * result, and returns `null`. The blocked copy then offers a new chat instead of
+ * Compact, which is the honest advice.
+ *
+ * Not a contrived shape either — one oversized file read or query result does
+ * exactly this in a real conversation.
+ */
+const WALL_RESULT_TOKENS = 24_000;
+
+const WALL: ChatMessage[] = stamped([
+  user('Read the whole reconciliation archive and summarise it.'),
+  {
+    role: 'assistant',
+    content: '',
+    agentName: 'Reconciliation',
+    toolCalls: [{ id: 'wall', name: 'read_archive', args: { path: '/archive/2026-08.csv' } }],
+  },
+  {
+    role: 'tool',
+    content: '',
+    agentName: 'Reconciliation',
+    toolResult: {
+      toolCallId: 'wall',
+      content: `Reconciliation archive. ${bulk(WALL_RESULT_TOKENS)}`,
+    },
+  },
+]);
+
 export const TRANSCRIPTS = {
   empty: [] as ChatMessage[],
   short: SHORT,
   rich: RICH,
   long: LONG,
+  huge: HUGE,
+  loop: LOOP,
+  wall: WALL,
 } as const;
 
 export type TranscriptName = keyof typeof TRANSCRIPTS;
@@ -266,7 +383,22 @@ const countAgentsInPrompt = (systemPrompt?: string): number =>
 export class SandboxAIProvider implements AIProvider {
   /** Round-trip delay: long enough to see the busy states, short enough not to annoy. */
   private static readonly LATENCY_MS = 1200;
-  private static readonly CONTEXT_LIMIT = 200_000;
+
+  /**
+   * The window `getStatus` reports, and so the one every context threshold is
+   * derived from (GENC-1567).
+   *
+   * **Mutable, and the sandbox writes it before each apply.** Setting
+   * `assistant.contextLimit` alone would not hold: the element re-resolves the
+   * limit from the provider whenever the active provider changes, and would
+   * overwrite a value poked onto it directly. Driving the provider instead means
+   * the immediate value and any later re-resolve agree.
+   *
+   * Shrinking it is the practical way to exercise the gate: at a real 200k
+   * window the block sits at 175k, and seeding a transcript that large would
+   * make the page miserable to work in.
+   */
+  contextLimit = DEFAULT_CONTEXT_LIMIT;
 
   private turn = 0;
   private route = 0;
@@ -275,7 +407,7 @@ export class SandboxAIProvider implements AIProvider {
     return {
       provider: 'none',
       model: 'sandbox-stub',
-      contextLimit: SandboxAIProvider.CONTEXT_LIMIT,
+      contextLimit: this.contextLimit,
     };
   }
 
@@ -307,9 +439,34 @@ export class SandboxAIProvider implements AIProvider {
     return { role: 'assistant', content: reply };
   }
 
-  async prompt(): Promise<string> {
-    // Side-calls (suggestion generation, summarisation) land here. There is
-    // nothing useful to invent, so return nothing and let the caller skip.
-    return '';
+  /**
+   * Side-calls land here — suggestion generation and, more usefully, compaction's
+   * one-shot summariser.
+   *
+   * It answers the summariser for real (GENC-1567) rather than returning nothing
+   * as it used to. That empty string made **Compact** a dead control in the
+   * sandbox: the driver treats an empty summary as a failure, leaves history
+   * untouched and appends its apology, so the one path worth exercising by hand
+   * could not be. The reply is canned, but everything around it — the plan, the
+   * splice, the divider, the shrunken context and the gate clearing — is real.
+   *
+   * Suggestions are told apart by their own prompt convention and still get
+   * nothing, since there is nothing useful to invent for those.
+   */
+  async prompt(userMessage: string, options?: { systemPrompt?: string }): Promise<string> {
+    const isSummary = /compress a conversation transcript/i.test(options?.systemPrompt ?? '');
+    if (!isSummary) return '';
+    await sleep(SandboxAIProvider.LATENCY_MS);
+    // Report the size actually handed over, so a hand-check of the compaction
+    // plan has something concrete to compare against.
+    const chars = userMessage.length;
+    return (
+      'Earlier in this conversation the user worked through positions, breaks and ' +
+      'reporting with the assistant, and a daily rates break report was scheduled. ' +
+      `(Sandbox summary standing in for ~${Math.round(
+        chars / APPROX_CHARS_PER_TOKEN,
+      ).toLocaleString()} tokens ` +
+      'of compacted transcript.)'
+    );
   }
 }

package/sandbox/sandbox.css

@@ -120,7 +120,11 @@ body {
 .viewport {
   overflow: hidden;
   resize: both;
-  min-width: 240px;
+
+  /* 400px is the narrowest supported composer — the blocked-state copy is sized
+     against it — so the drag handle stops there rather than letting the stage
+     reach widths the component is not built for. */
+  min-width: 400px;
   min-height: 240px;
   border: 1px solid var(--sb-line);
   border-radius: 6px;
@@ -210,6 +214,55 @@ rapid-design-system-provider {
   padding-bottom: 8px;
 }
 
+/* The one control a group is really about — lifted out of the list so it reads as
+   the entry point rather than the first of eight equal rows. Deliberately quiet:
+   a tinted panel and an accent edge, not a colour that competes with the stage. */
+.row-featured {
+  /* Content stays on the same left edge as every other row: the shared .row pads
+     14px, and the 2px accent border here eats 2 of them, so the padding makes up
+     the remaining 12. Getting this wrong is immediately visible as a highlighted
+     block whose label is indented differently from its neighbours. */
+  margin: 0 0 6px;
+  padding: 8px 14px 8px 12px;
+  border-left: 2px solid var(--sb-accent);
+  background: color-mix(in srgb, var(--sb-accent) 8%, transparent);
+}
+
+.row-featured .label {
+  color: var(--sb-text);
+  font-weight: 600;
+}
+
+/* Stacked, not inline. The shared row gives a select a fixed 140px, which clips
+   these option labels to "Blocked — compacting will…" — losing the clause that
+   distinguishes the two blocked states, which is the whole reason they are
+   separate entries. Full width costs nothing here and keeps them readable. */
+.row-featured {
+  flex-direction: column;
+  align-items: stretch;
+}
+
+.row-featured select {
+  flex: 1 1 auto;
+  width: 100%;
+}
+
+/* A derived figure read back off the component, not a control. Monospace and
+   wrapping, because these are numbers meant to be compared by eye and some of
+   them (the compact hint) are a whole sentence. */
+.row-readout {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.readout-value {
+  color: var(--sb-text);
+  font-family: ui-monospace, sfmono-regular, menlo, monospace;
+  font-size: 11px;
+  overflow-wrap: anywhere;
+}
+
 .action {
   width: 100%;
   padding: 5px 10px;