@genesislcap/ai-assistant 15.19.6 → 15.20.0-alpha.3

package/dist/esm/utils/resolve-context-budget.js

@@ -0,0 +1,84 @@
+import { COMPACTION_SUMMARY_TOKEN_ESTIMATE } from './context-tokens';
+// Re-exported, not redeclared: this module and `planCompaction` must apply the
+// SAME worth-it floor, or a host passing explicit options and a caller relying
+// on the module default would silently disagree about whether a compaction is
+// worth running. `history-transform` owns it because that is where the plan is
+// made; this module only threads it through.
+import { DEFAULT_MIN_RECLAIM_TOKENS } from './history-transform';
+export { DEFAULT_MIN_RECLAIM_TOKENS };
+/**
+ * Context headroom thresholds (GENC-1567) — resolving `chatConfig.context`,
+ * the active model's window, and any per-agent reserve into the four numbers
+ * the gate and the compaction planner actually read.
+ */
+/**
+ * Tokens kept free for a single turn by default.
+ *
+ * A turn is not atomic in cost: a send allowed just under a threshold can run a
+ * long tool loop and add a great deal on its own, so what has to be bounded is
+ * the growth of ONE turn — a token count, not a fraction of the window. On a
+ * 200k model this leaves ~12% free; on a 1M model the same absolute room, rather
+ * than the 200k a percentage rule would strand.
+ *
+ * Chosen as a starting position, not a measured figure. Per-turn `inputTokens`
+ * is recorded for every call, so this should be revisited against real traffic.
+ */
+export const DEFAULT_RESERVE_TOKENS = 25000;
+/** Warning appears this many reserves ahead of the block. */
+export const DEFAULT_WARN_MULTIPLIER = 2;
+/**
+ * How close to the window a running turn is allowed to get before the driver
+ * stops it (GENC-1567). Roughly one more tool result plus a reply — enough that
+ * the next request would very likely be refused.
+ */
+export const CONTEXT_ABORT_MARGIN_TOKENS = 4096;
+/**
+ * Resolve the headroom thresholds for the active model and agent.
+ *
+ * Everything downstream — the warning, the block, the compaction planner and the
+ * banner copy — reads this one result, so the thresholds a user is judged
+ * against and the budget compaction aims at can never disagree.
+ */
+export function resolveContextBudget(input) {
+    var _a, _b, _c;
+    const { chatConfig, contextLimit, agentReserveTokens, systemOverhead = 0 } = input;
+    const cfg = chatConfig.context;
+    const reserveTokens = Math.max(0, (_a = agentReserveTokens !== null && agentReserveTokens !== void 0 ? agentReserveTokens : cfg === null || cfg === void 0 ? void 0 : cfg.reserveTokens) !== null && _a !== void 0 ? _a : DEFAULT_RESERVE_TOKENS);
+    const warnMultiplier = Math.max(1, (_b = cfg === null || cfg === void 0 ? void 0 : cfg.warnMultiplier) !== null && _b !== void 0 ? _b : DEFAULT_WARN_MULTIPLIER);
+    const minReclaimTokens = Math.max(0, (_c = cfg === null || cfg === void 0 ? void 0 : cfg.minReclaimTokens) !== null && _c !== void 0 ? _c : DEFAULT_MIN_RECLAIM_TOKENS);
+    const limit = contextLimit !== null && contextLimit !== void 0 ? contextLimit : cfg === null || cfg === void 0 ? void 0 : cfg.fallbackContextLimit;
+    // No limit → no thresholds. The gate stays inert rather than guessing a window
+    // and blocking the composer against the guess.
+    if (limit == null || limit <= 0) {
+        return {
+            enabled: false,
+            limit: undefined,
+            reserveTokens,
+            tailTokenBudget: Math.max(0, reserveTokens),
+            minReclaimTokens,
+        };
+    }
+    const enabled = (cfg === null || cfg === void 0 ? void 0 : cfg.enabled) !== false;
+    const blockAt = Math.max(0, limit - reserveTokens);
+    const warnAt = Math.max(0, limit - warnMultiplier * reserveTokens);
+    // Aim compaction at the warning line, and leave room for the summary itself.
+    // Floored at one reserve so a pathological config (a reserve wider than the
+    // window) still asks for a tail rather than an impossible zero.
+    const tailTokenBudget = Math.max(reserveTokens, warnAt - systemOverhead - COMPACTION_SUMMARY_TOKEN_ESTIMATE);
+    return {
+        enabled,
+        limit,
+        reserveTokens,
+        warnAt,
+        blockAt,
+        tailTokenBudget,
+        minReclaimTokens,
+        // Withheld when the host opted out. `enabled: false` is documented as "no
+        // warning and no block", and a host that would rather take the provider's
+        // answer than ever have its composer disabled means the mid-loop guard too —
+        // otherwise the visible gate disappears as asked while a long tool loop still
+        // dies with `context-exhausted`, which is the same refusal wearing a
+        // different hat.
+        abortAt: enabled ? Math.max(blockAt, limit - CONTEXT_ABORT_MARGIN_TOKENS) : undefined,
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.19.6",
+  "version": "15.20.0-alpha.3",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -74,26 +74,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.19.6",
-    "@genesislcap/genx": "15.19.6",
-    "@genesislcap/rollup-builder": "15.19.6",
-    "@genesislcap/ts-builder": "15.19.6",
-    "@genesislcap/uvu-playwright-builder": "15.19.6",
-    "@genesislcap/vite-builder": "15.19.6",
-    "@genesislcap/webpack-builder": "15.19.6",
+    "@genesislcap/foundation-testing": "15.20.0-alpha.3",
+    "@genesislcap/genx": "15.20.0-alpha.3",
+    "@genesislcap/rollup-builder": "15.20.0-alpha.3",
+    "@genesislcap/ts-builder": "15.20.0-alpha.3",
+    "@genesislcap/uvu-playwright-builder": "15.20.0-alpha.3",
+    "@genesislcap/vite-builder": "15.20.0-alpha.3",
+    "@genesislcap/webpack-builder": "15.20.0-alpha.3",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.19.6",
-    "@genesislcap/foundation-logger": "15.19.6",
-    "@genesislcap/foundation-notifications": "15.19.6",
-    "@genesislcap/foundation-redux": "15.19.6",
-    "@genesislcap/foundation-ui": "15.19.6",
-    "@genesislcap/foundation-utils": "15.19.6",
-    "@genesislcap/rapid-design-system": "15.19.6",
-    "@genesislcap/web-core": "15.19.6",
+    "@genesislcap/foundation-ai": "15.20.0-alpha.3",
+    "@genesislcap/foundation-logger": "15.20.0-alpha.3",
+    "@genesislcap/foundation-notifications": "15.20.0-alpha.3",
+    "@genesislcap/foundation-redux": "15.20.0-alpha.3",
+    "@genesislcap/foundation-ui": "15.20.0-alpha.3",
+    "@genesislcap/foundation-utils": "15.20.0-alpha.3",
+    "@genesislcap/rapid-design-system": "15.20.0-alpha.3",
+    "@genesislcap/web-core": "15.20.0-alpha.3",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },

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.)'
+    );
   }
 }