@north-light/crouter 0.3.206 → 0.3.208

package/dist/api/dto/messages.d.ts

@@ -22,9 +22,10 @@ export interface SendMessageRequest {
     /** Clear a latched target's finalization latch before an immediate delivery
      *  or `--fresh` revive (`--reopen`). Immediate only. */
     reopen?: boolean;
-    /** Hidden ambient context upserted onto the target's sidecar and delivered as
-     *  a `<situational-context>` block, never visible chat (`--situational-context`).
-     *  Immediate only; valid alone (no body). */
+    /** Hidden ambient context upserted onto the target's sidecar as a
+     *  `situational` card, never visible chat (`--situational-context`).
+     *  Immediate only; valid alone (no body). Prose only — its body is NOT
+     *  escaped; a caller with untrusted text uses `situational_card`. */
     situational_context?: string;
     /** A runtime card that REPLACES the target's situational sidecar, delivered
      *  ahead of the body in the same turn and re-stated by the session-start

package/dist/clients/attach/__tests__/group-activity.test.js

@@ -70,7 +70,14 @@ test('a folded recap carries paths and counts, never diff or write payload bodie
         bashMode: tone('bashMode'), bashModeAlt: tone('bashModeAlt'),
     };
     const recap = new GroupRecapComponent();
-    recap.setRecap({ bullets: ['finished'], filesDeleted: 2 }, 2, { memories: [{ action: 'read', name: 'alpha', path: '/tmp/memories/alpha.md' }], files: recorder.activity().files, nodes: [] }, true, palette);
+    recap.setRecap({ bullets: ['finished'], filesDeleted: 2 }, 2, {
+        memories: [{ action: 'read', name: 'alpha', path: '/tmp/memories/alpha.md' }],
+        files: recorder.activity().files,
+        nodes: [],
+        cards: [],
+        events: [],
+        eventsOmitted: 0,
+    }, true, palette);
     const text = recap.render(120).join('\n');
     assert.match(text, /overwritten\.ts/, 'the recap still names what changed');
     assert.doesNotMatch(text, /sensitive-old-diff|sensitive-new-diff|sensitive-write-payload/, 'payload bodies never leak into a recap');

package/dist/clients/attach/render/card-presentation.d.ts

@@ -0,0 +1,31 @@
+import { type GeneratedCard } from '../../../shared/generated-context.js';
+/** What the one global detail toggle reveals for this kind.
+ *  `section` names an element in the body; everything outside it stays folded. */
+export type CardExpandedPolicy = {
+    readonly disclose: 'never';
+} | {
+    readonly disclose: 'payload';
+} | {
+    readonly disclose: 'section';
+    readonly section: string;
+};
+/** What is left of the card once its turn folds into one recap line. A boundary
+ *  kind never reaches this field — `isGroupBoundaryKind` removes it from the
+ *  group first — so every case here is a member policy. */
+export type CardGroupFoldedPolicy = 'omit' | 'event' | 'activity' | 'senders';
+export interface CardPresentation {
+    /** The noun in `[crtr <subject>]`. Never a full label — the prefix is generated. */
+    readonly subject: string;
+    readonly summary: (card: GeneratedCard) => string;
+    readonly expanded: CardExpandedPolicy;
+    readonly groupFolded: CardGroupFoldedPolicy;
+}
+/** Every label in the transcript reads the same way; no definition stores one. */
+export declare function cardLabel(subject: string): string;
+/** The disclosure a card actually offers, given its policy and body. A kind
+ *  whose section is missing from an old transcript offers nothing to expand. */
+export declare function cardDisclosure(presentation: CardPresentation, body: string): string;
+export declare function cardIsExpandable(presentation: CardPresentation, body: string): boolean;
+/** The one lookup. Every display surface deciding how a card behaves resolves it
+ *  here, so row, disclosure, and recap can never disagree about a kind. */
+export declare function presentationFor(kind: string): CardPresentation;

package/dist/clients/attach/render/card-presentation.js

@@ -0,0 +1,163 @@
+// The terminal's presentation policy for runtime cards. One kind, one
+// definition: what the collapsed row says, what the global detail toggle
+// discloses, and what survives when the surrounding tool group folds into a
+// recap. Renderers read these policies and never compare kinds.
+//
+// This is display policy, not a wire contract — nothing outside
+// clients/attach/** reads it. The one fact the broker must agree with lives in
+// shared/tool-groups.ts (`isGroupBoundaryKind`), because segmenting a tool run
+// on different seams would make the recap describe a span nobody saw.
+//
+// Every summary derives from the PARSED card — its body and its sender
+// attribution — never from envelope facts, which are leaving the wire.
+import { AUTH_FAULT_RECOVERY_BODY, CONNECTION_FAULT_RECOVERY_BODY, PROVIDER_FAULT_RECOVERY_BODY, } from '../../../shared/generated-context.js';
+const NEVER = { disclose: 'never' };
+const PAYLOAD = { disclose: 'payload' };
+/** Every label in the transcript reads the same way; no definition stores one. */
+export function cardLabel(subject) {
+    return `crtr ${subject}`;
+}
+/** Body of a `section` disclosure. An absent section discloses nothing rather
+ *  than falling back to the whole payload, which is what the section policy
+ *  exists to avoid showing. */
+function extractCardSection(body, section) {
+    const match = new RegExp(`<${section}\\b[^>]*>([\\s\\S]*?)</${section}>`).exec(body);
+    return match ? match[1].trim() : '';
+}
+/** The disclosure a card actually offers, given its policy and body. A kind
+ *  whose section is missing from an old transcript offers nothing to expand. */
+export function cardDisclosure(presentation, body) {
+    switch (presentation.expanded.disclose) {
+        case 'never': return '';
+        case 'payload': return body;
+        case 'section': return extractCardSection(body, presentation.expanded.section);
+    }
+}
+export function cardIsExpandable(presentation, body) {
+    return cardDisclosure(presentation, body).length > 0;
+}
+function inboxSummary(card) {
+    if (card.senders.length === 0)
+        return 'inbox update';
+    const updates = card.senders.reduce((total, sender) => total + sender.updates, 0);
+    if (card.senders.length === 1)
+        return `${updates === 1 ? 'message' : `${updates} messages`} received`;
+    return `${updates} messages received from ${card.senders.length} nodes`;
+}
+/** Recovery bodies are the fixed prompts shared with the producer; the
+ *  model-fallback prompt names its two routes, so it is recognized by the one
+ *  clause both of its variants build around. */
+function recoverySummary(card) {
+    switch (card.body) {
+        case AUTH_FAULT_RECOVERY_BODY: return 'provider credentials updated';
+        case CONNECTION_FAULT_RECOVERY_BODY: return 'network connection restored';
+        case PROVIDER_FAULT_RECOVERY_BODY: return 'provider retry';
+        default: return card.body.includes('automatically switched to ') ? 'model route changed' : 'runtime recovery';
+    }
+}
+/** The comment notice opens by naming what happened to the comment
+ *  (daemon/review/comment-notify.ts). */
+const REVIEW_COMMENT_VERB = /^Review comment \S+ was (created|edited|resolved|reopened|deleted)\b/;
+function reviewCommentSummary(card) {
+    const verb = REVIEW_COMMENT_VERB.exec(card.body)?.[1];
+    return verb === undefined ? 'review comment updated' : `review comment ${verb}`;
+}
+/** Both structured-output reprompts open this way (core/runtime/stop-guard.ts);
+ *  the stall reprompt does not. */
+const STRUCTURED_OUTPUT_REPROMPT = /^(?:You must call the `submit` tool|Structured-output request file is invalid)/;
+function stopGuardSummary(card) {
+    return STRUCTURED_OUTPUT_REPROMPT.test(card.body) ? 'structured output required' : 'completion required';
+}
+/** Presentation for crouter's own kinds. `situational` is deliberately absent:
+ *  it is migrating under separate ownership and adopts this contract after. */
+const CORE_CARD_PRESENTATIONS = {
+    inbox: {
+        subject: 'inbox',
+        summary: inboxSummary,
+        expanded: PAYLOAD,
+        groupFolded: 'senders',
+    },
+    revive: {
+        subject: 'revive',
+        summary: () => 'fresh context',
+        expanded: { disclose: 'section', section: 'yield-message' },
+        groupFolded: 'omit',
+    },
+    // A boundary kind: `isGroupBoundaryKind` keeps it out of every group, so its
+    // `groupFolded` is never read.
+    'restart-continuation': {
+        subject: 'continuation',
+        summary: () => 'continuing after restart',
+        expanded: NEVER,
+        groupFolded: 'omit',
+    },
+    'stop-guard': {
+        subject: 'stop guard',
+        summary: stopGuardSummary,
+        expanded: NEVER,
+        groupFolded: 'event',
+    },
+    recovery: {
+        subject: 'recovery',
+        summary: recoverySummary,
+        expanded: NEVER,
+        groupFolded: 'event',
+    },
+    'persona-transition': {
+        subject: 'persona',
+        summary: () => 'role updated',
+        expanded: NEVER,
+        groupFolded: 'event',
+    },
+    'review-approval': {
+        subject: 'review',
+        summary: () => 'approved by the user',
+        expanded: PAYLOAD,
+        groupFolded: 'activity',
+    },
+    'review-comment': {
+        subject: 'review',
+        summary: reviewCommentSummary,
+        expanded: PAYLOAD,
+        groupFolded: 'activity',
+    },
+    'review-queued': {
+        subject: 'review',
+        summary: () => 'submitted; finishing',
+        expanded: NEVER,
+        groupFolded: 'omit',
+    },
+    'context-nudge': {
+        subject: 'context',
+        summary: () => 'context-window guidance',
+        expanded: NEVER,
+        groupFolded: 'omit',
+    },
+    bearings: {
+        subject: 'context',
+        summary: () => 'orienting context',
+        expanded: { disclose: 'section', section: 'auto-loaded-context' },
+        groupFolded: 'omit',
+    },
+    // A boundary kind, as above.
+    'review-boundary': {
+        subject: 'review',
+        summary: () => 'earlier conversation hidden',
+        expanded: NEVER,
+        groupFolded: 'omit',
+    },
+};
+/** Any kind without a definition — an unregistered product kind, a removed
+ *  plugin, an old transcript. It stays readable and is never misattributed to
+ *  the person, so a missing definition is not an error condition. */
+const GENERIC_CARD_PRESENTATION = {
+    subject: 'runtime',
+    summary: () => 'runtime context',
+    expanded: PAYLOAD,
+    groupFolded: 'event',
+};
+/** The one lookup. Every display surface deciding how a card behaves resolves it
+ *  here, so row, disclosure, and recap can never disagree about a kind. */
+export function presentationFor(kind) {
+    return CORE_CARD_PRESENTATIONS[kind] ?? GENERIC_CARD_PRESENTATION;
+}

package/dist/clients/attach/render/chat-view.d.ts

@@ -255,8 +255,6 @@ export declare class ChatView {
     private ensureGroup;
     private closeOpenGroup;
     private appendGroupMember;
-    /** Used for context that may join an existing run but must not create one. */
-    private appendExistingGroupMember;
     private removeGroupMember;
     /** Add one tool as a group member, moving the assistant's boundary separator
      * behind the new summary row without changing the separator's identity. */

package/dist/clients/attach/render/chat-view.js

@@ -23,12 +23,13 @@
 import { Container, Loader, Spacer, Text } from '@earendil-works/pi-tui';
 import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomMessageComponent, parseSkillBlock, SkillInvocationMessageComponent, ToolExecutionComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
 import { attachMarkdownTheme } from '../config.js';
-import { ContextMessageComponent, contextCardBody, expandsWithTools } from './context-message.js';
+import { ContextMessageComponent } from './context-message.js';
+import { presentationFor } from './card-presentation.js';
 import { detectInlinePageResult, PageBlockComponent } from './page-block.js';
 import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output.js';
 import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE, endedByAbort } from '../../../core/runtime/session-cycles.js';
 import { parseCard } from '../../../shared/generated-context.js';
-import { assistantVisibleText, isTrueUserMessage, } from '../../../shared/tool-groups.js';
+import { assistantVisibleText, isGroupBoundaryKind, isTrueUserMessage, } from '../../../shared/tool-groups.js';
 import { transformDiagramFences } from './diagram.js';
 import { styleAttachAgentMarkdown, styleAttachMarkdownSource, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-source.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
@@ -1047,25 +1048,19 @@ export class ChatView {
                 && card.body.replace(INBOX_SENDER_SECTIONS, '').trim() === ''
                 && card.senders.every((sender) => sender.entries.every((entry) => entry.disposition === 'human-answer'));
             if (!onlyHumanWords) {
-                const component = new ContextMessageComponent(contextCardBody(card), this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), card.label, ` ${card.summary} — ctrl+o to expand`, expandsWithTools(card));
-                // A successor broker's exact restart continuation is a visible seam, not
-                // a group member: the preceding span keeps its own recap and the next tool
-                // call begins a broker-aligned fresh group.
-                if (card.kind === 'restart-continuation') {
+                const presentation = presentationFor(card.kind);
+                const component = new ContextMessageComponent(card, presentation, this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)));
+                // A boundary card is a visible seam, not a group member: the preceding
+                // span keeps its own recap and the next tool call begins a
+                // broker-aligned fresh group.
+                if (isGroupBoundaryKind(card.kind)) {
                     this.closeOpenGroup();
                     this.append(component);
-                    // Bearings and revive kickoffs only belong to an already-open run; they
-                    // never create a summary block by themselves. Other injected context may.
-                }
-                else if (card.kind === 'bearings' || card.kind === 'revive') {
-                    this.appendExistingGroupMember(component);
                 }
                 else {
-                    const group = this.appendGroupMember(component);
-                    // A child's final arrives as an inbox digest, not a tool call: without
-                    // this the folded recap would hide the one row saying it finished.
-                    if (card.kind === 'inbox')
-                        group?.activity.noteInboxDigest(card);
+                    // A folded group hides its members, so whatever the card should leave
+                    // behind — a child's final, a recovery — reaches the recap here.
+                    this.appendGroupMember(component)?.activity.noteCard(card, presentation);
                 }
             }
             for (const answer of answers)
@@ -1259,12 +1254,6 @@ export class ChatView {
             group.members.push(component);
         return group;
     }
-    /** Used for context that may join an existing run but must not create one. */
-    appendExistingGroupMember(component) {
-        this.append(component);
-        if (this.isLiveGroupRegion() && this.openGroup)
-            this.openGroup.members.push(component);
-    }
     removeGroupMember(component) {
         for (const group of this.groups) {
             const index = group.members.indexOf(component);

package/dist/clients/attach/render/context-message.d.ts

@@ -1,19 +1,15 @@
 import { type Component } from '@earendil-works/pi-tui';
+import { type CardPresentation } from './card-presentation.js';
 import type { GeneratedCard } from '../../../shared/generated-context.js';
-export declare function expandsWithTools(card: GeneratedCard): boolean;
-/** What a card discloses when expanded. Bearings and a revive kickoff carry a
- * long mandate around one region worth re-reading; every other card discloses
- * the body the agent was given. */
-export declare function contextCardBody(card: GeneratedCard): string;
 export declare class ContextMessageComponent implements Component {
     private readonly dim;
     private readonly label;
-    private readonly labelText;
-    private readonly collapsedHint;
-    private readonly expandsWithTools;
     private expanded;
+    private readonly expandable;
+    private readonly labelTag;
+    private readonly collapsedHint;
     private readonly expandedBody;
-    constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string, labelText?: string, collapsedHint?: string, expandsWithTools?: boolean);
+    constructor(card: GeneratedCard, presentation: CardPresentation, expanded: boolean, dim: (s: string) => string, label: (s: string) => string);
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;
     render(width: number): string[];

package/dist/clients/attach/render/context-message.js

@@ -1,58 +1,37 @@
 // render/context-message.ts — the terminal viewer's foldable renderer for
 // crouter-generated context. Session bearings, situational updates, lifecycle
 // steering, recovery prompts, and inbox digests retain their model-visible body
-// and runtime role. This display-only component renders the disclosure body it
-// receives: collapsed → a padded dim line; expanded (Ctrl+O) → the ordinary
-// user-message surface, regardless of the message's runtime role. Selected
-// cards implement `setExpanded` for the global tool-display cycle; other cards
-// remain folded while tool output is shown. Classification lives in
-// shared/generated-context.ts; this module owns only what a parsed card
-// discloses and how it renders.
+// and runtime role. This display-only component paints one parsed card through
+// its presentation: collapsed → a padded dim line; expanded (Ctrl+O) → the
+// ordinary user-message surface, regardless of the message's runtime role.
+// Classification lives in shared/generated-context.ts and every per-kind
+// decision in ./card-presentation.ts; this module owns only the painting.
 import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { attachMarkdownTheme } from '../config.js';
+import { cardDisclosure, cardIsExpandable, cardLabel, } from './card-presentation.js';
 import { styleAttachMarkdownSource } from './markdown-source.js';
-/** Default label/hint for the `crtr-context` bearings block. */
-const LABEL = 'crtr context';
-const COLLAPSED_HINT = ' orienting bearings — ctrl+o to expand';
-const AUTO_LOADED_CONTEXT_BLOCK = /<auto-loaded-context>([\s\S]*?)<\/auto-loaded-context>/;
-const YIELD_MESSAGE_BLOCK = /<yield-message>([\s\S]*?)<\/yield-message>/;
-/** Cards the global ctrl+o cycle expands; every other card stays folded while
- * tool output is shown. */
-const EXPANDS_WITH_TOOLS = new Set(['bearings', 'revive', 'inbox', 'review-approval']);
-export function expandsWithTools(card) {
-    return EXPANDS_WITH_TOOLS.has(card.kind);
-}
-/** What a card discloses when expanded. Bearings and a revive kickoff carry a
- * long mandate around one region worth re-reading; every other card discloses
- * the body the agent was given. */
-export function contextCardBody(card) {
-    if (card.kind === 'bearings')
-        return AUTO_LOADED_CONTEXT_BLOCK.exec(card.body)?.[1]?.trim() ?? '';
-    if (card.kind === 'revive')
-        return YIELD_MESSAGE_BLOCK.exec(card.body)?.[1]?.trim() ?? '';
-    return card.body;
-}
 export class ContextMessageComponent {
     dim;
     label;
-    labelText;
-    collapsedHint;
-    expandsWithTools;
     expanded;
+    expandable;
+    labelTag;
+    collapsedHint;
     expandedBody;
-    constructor(body, expanded, dim, label, labelText = LABEL, collapsedHint = COLLAPSED_HINT, expandsWithTools = true) {
+    constructor(card, presentation, expanded, dim, label) {
         this.dim = dim;
         this.label = label;
-        this.labelText = labelText;
-        this.collapsedHint = collapsedHint;
-        this.expandsWithTools = expandsWithTools;
-        this.expanded = expandsWithTools && expanded;
-        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(body), attachMarkdownTheme());
+        this.expandable = cardIsExpandable(presentation, card.body);
+        this.expanded = this.expandable && expanded;
+        this.labelTag = `[${cardLabel(presentation.subject)}]`;
+        // A card with nothing to disclose must not advertise the toggle.
+        this.collapsedHint = ` ${presentation.summary(card)}${this.expandable ? ' — ctrl+o to expand' : ''}`;
+        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(cardDisclosure(presentation, card.body)), attachMarkdownTheme());
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {
-        if (this.expandsWithTools)
+        if (this.expandable)
             this.expanded = expanded;
     }
     render(width) {
@@ -62,12 +41,10 @@ export class ContextMessageComponent {
             // reads distinctly in BOTH states. Truncate BEFORE painting so the ANSI
             // wrappers never inflate the measured width (an over-wide line aborts the
             // whole TUI render).
-            const labelTag = `[${this.labelText}]`;
-            const rest = this.collapsedHint;
-            const labelW = visibleWidth(labelTag);
+            const labelW = visibleWidth(this.labelTag);
             if (labelW >= w)
-                return ['', this.label(truncateToWidth(labelTag, w, '…')), ''];
-            return ['', this.label(labelTag) + this.dim(truncateToWidth(rest, w - labelW, '…')), ''];
+                return ['', this.label(truncateToWidth(this.labelTag, w, '…')), ''];
+            return ['', this.label(this.labelTag) + this.dim(truncateToWidth(this.collapsedHint, w - labelW, '…')), ''];
         }
         const lines = this.expandedBody.render(w);
         if (lines.at(-1) !== '')

package/dist/clients/attach/render/group-activity.d.ts

@@ -1,3 +1,4 @@
+import type { CardPresentation } from './card-presentation.js';
 import type { GeneratedCard } from '../../../shared/generated-context.js';
 export type FileActivity = {
     key: string;
@@ -20,10 +21,24 @@ export type NodeActivity = {
     name: string;
     id: string;
 };
+/** A card whose fold-time contribution is structured: its own summary line. */
+export type CardActivity = {
+    summary: string;
+};
+/** A card that folds to one terse line. Repeats compress into `count` so a run
+ * of recoveries costs one row, not one row each. */
+export type EventActivity = {
+    text: string;
+    count: number;
+};
 export type GroupActivity = {
     files: readonly FileActivity[];
     memories: readonly MemoryActivity[];
     nodes: readonly NodeActivity[];
+    cards: readonly CardActivity[];
+    events: readonly EventActivity[];
+    /** Distinct events past the budget, so the recap can say what it dropped. */
+    eventsOmitted: number;
 };
 /** Per-group recorder. Calls retain only their current transcript references
  * until they settle; the settled activity is plain immutable evidence. */
@@ -36,17 +51,26 @@ export declare class GroupActivityRecorder {
     private readonly memorySet;
     private readonly nodes;
     private readonly nodeSet;
+    private readonly cards;
+    private readonly cardSet;
+    private readonly events;
+    private eventsOmitted;
     /** `roster` is the ChatView-wide node id → display name record: spawns fill
      * it, and a later group's finish reads the name a sibling group recorded. */
     constructor(cwd: string, roster?: Map<string, string>);
-    /** Record the nodes an inbox digest reports finished. The spawn roster supplies
-     * the display name when it has one. A sender carrying only the person's own
-     * words is the human speaking, not a node that finished. */
-    noteInboxDigest(card: GeneratedCard): void;
+    /** What one runtime card leaves behind when its group folds, decided entirely
+     * by the card's presentation policy. */
+    noteCard(card: GeneratedCard, presentation: CardPresentation): void;
     noteCall(id: string, name: string, args: unknown): void;
     settle(id: string, result: unknown, isError: boolean): void;
     resolveWithoutResult(id: string): void;
     activity(): GroupActivity;
+    /** The nodes an inbox digest reports finished. The spawn roster supplies the
+     * display name when it has one. A sender carrying only the person's own words
+     * is the human speaking, not a node that finished. */
+    private addFinishedSenders;
+    private addCard;
+    private addEvent;
     private addNode;
     private extract;
 }

package/dist/clients/attach/render/group-activity.js

@@ -4,10 +4,15 @@
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { countDisplayDiffLines } from './edit-diff.js';
+/** Distinct event lines one recap will show before it starts counting. */
+const MAX_RECAP_EVENTS = 3;
 const EMPTY_ACTIVITY = Object.freeze({
     files: Object.freeze([]),
     memories: Object.freeze([]),
     nodes: Object.freeze([]),
+    cards: Object.freeze([]),
+    events: Object.freeze([]),
+    eventsOmitted: 0,
 });
 function object(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
@@ -155,22 +160,31 @@ export class GroupActivityRecorder {
     memorySet = new Set();
     nodes = [];
     nodeSet = new Set();
+    cards = [];
+    cardSet = new Set();
+    events = new Map();
+    eventsOmitted = 0;
     /** `roster` is the ChatView-wide node id → display name record: spawns fill
      * it, and a later group's finish reads the name a sibling group recorded. */
     constructor(cwd, roster = new Map()) {
         this.cwd = cwd;
         this.roster = roster;
     }
-    /** Record the nodes an inbox digest reports finished. The spawn roster supplies
-     * the display name when it has one. A sender carrying only the person's own
-     * words is the human speaking, not a node that finished. */
-    noteInboxDigest(card) {
-        for (const sender of card.senders) {
-            const onlyHumanWords = sender.entries.length > 0
-                && sender.entries.every((entry) => entry.disposition === 'human-answer');
-            if (!sender.finished || onlyHumanWords)
-                continue;
-            this.addNode({ action: 'finished', name: this.roster.get(sender.id) ?? sender.id, id: sender.id });
+    /** What one runtime card leaves behind when its group folds, decided entirely
+     * by the card's presentation policy. */
+    noteCard(card, presentation) {
+        switch (presentation.groupFolded) {
+            case 'omit':
+                return;
+            case 'event':
+                this.addEvent(presentation.summary(card));
+                return;
+            case 'activity':
+                this.addCard({ summary: presentation.summary(card) });
+                return;
+            case 'senders':
+                this.addFinishedSenders(card);
+                return;
         }
     }
     noteCall(id, name, args) {
@@ -197,17 +211,57 @@ export class GroupActivityRecorder {
         entry.args = undefined;
     }
     activity() {
-        if (this.files.size === 0 && this.memories.length === 0 && this.nodes.length === 0)
+        if (this.files.size === 0 && this.memories.length === 0 && this.nodes.length === 0
+            && this.cards.length === 0 && this.events.size === 0)
             return EMPTY_ACTIVITY;
         const files = [...this.files.values()].map((file) => Object.freeze({ ...file }));
         const memories = this.memories.map((memory) => Object.freeze({ ...memory }));
         const nodes = this.nodes.map((node) => Object.freeze({ ...node }));
+        const cards = this.cards.map((card) => Object.freeze({ ...card }));
+        const events = [...this.events].map(([text, count]) => Object.freeze({ text, count }));
         return Object.freeze({
             files: Object.freeze(files),
             memories: Object.freeze(memories),
             nodes: Object.freeze(nodes),
+            cards: Object.freeze(cards),
+            events: Object.freeze(events),
+            eventsOmitted: this.eventsOmitted,
         });
     }
+    /** The nodes an inbox digest reports finished. The spawn roster supplies the
+     * display name when it has one. A sender carrying only the person's own words
+     * is the human speaking, not a node that finished. */
+    addFinishedSenders(card) {
+        for (const sender of card.senders) {
+            const onlyHumanWords = sender.entries.length > 0
+                && sender.entries.every((entry) => entry.disposition === 'human-answer');
+            if (!sender.finished || onlyHumanWords)
+                continue;
+            this.addNode({ action: 'finished', name: this.roster.get(sender.id) ?? sender.id, id: sender.id });
+        }
+    }
+    addCard(card) {
+        const key = card.summary;
+        if (this.cardSet.has(key))
+            return;
+        this.cardSet.add(key);
+        this.cards.push(card);
+    }
+    addEvent(text) {
+        const line = text.trim();
+        if (line === '')
+            return;
+        const seen = this.events.get(line);
+        if (seen !== undefined) {
+            this.events.set(line, seen + 1);
+            return;
+        }
+        if (this.events.size >= MAX_RECAP_EVENTS) {
+            this.eventsOmitted += 1;
+            return;
+        }
+        this.events.set(line, 1);
+    }
     addNode(node) {
         const key = `${node.action}:${node.id}`;
         if (this.nodeSet.has(key))

package/dist/clients/attach/render/group-recap.d.ts

@@ -6,5 +6,8 @@ import type { GroupActivity } from './group-activity.js';
  * group is eligible to collapse, preserving the member rows for Ctrl+O. */
 export declare class GroupRecapComponent extends Container {
     setRecap(summary: ToolGroupSummary | undefined, toolCount: number, activity: GroupActivity, detailed: boolean, palette: AttachPalette): void;
+    /** Runtime cards the fold hid. Terse events are already compressed by count,
+     * so every card contributes exactly one row. */
+    private addCardEvidence;
     private addFile;
 }

package/dist/clients/attach/render/group-recap.js

@@ -8,6 +8,8 @@ import { TOOL_ICON } from '../../../core/preview-registry.js';
 const MEMORY_ICON = String.fromCodePoint(0xf02d);
 // trash — deletion has no tool of its own, so it borrows no TOOL_ICON entry.
 const DELETE_ICON = String.fromCodePoint(0xf1f8);
+// info-circle — runtime context the fold hid, kept as its own evidence line.
+const CARD_ICON = String.fromCodePoint(0xf05a);
 function count(value, singular, plural) {
     return `${value} ${value === 1 ? singular : plural}`;
 }
@@ -102,10 +104,25 @@ export class GroupRecapComponent extends Container {
             }
             this.addChild(new Text(stats.join(palette.muted(' · ')), 0, 0));
         }
+        this.addCardEvidence(activity, palette);
         for (const bullet of summary.bullets)
             this.addChild(new Text(palette.muted(`  • ${bullet.trim()}`), 0, 0));
         this.addChild(new Spacer(1));
     }
+    /** Runtime cards the fold hid. Terse events are already compressed by count,
+     * so every card contributes exactly one row. */
+    addCardEvidence(activity, palette) {
+        for (const card of activity.cards) {
+            this.addChild(new Text(`${palette.info(CARD_ICON)} ${palette.muted(card.summary)}`, 0, 0));
+        }
+        for (const event of activity.events) {
+            const repeats = event.count > 1 ? ` ×${event.count}` : '';
+            this.addChild(new Text(`${palette.info(CARD_ICON)} ${palette.muted(`${event.text}${repeats}`)}`, 0, 0));
+        }
+        if (activity.eventsOmitted > 0) {
+            this.addChild(new Text(palette.muted(`  ${count(activity.eventsOmitted, 'more runtime event', 'more runtime events')}`), 0, 0));
+        }
+    }
     addFile(file, palette) {
         const counts = file.hasKnownCounts
             ? `${palette.diffAdded(`+${file.added}`)}${file.kind === 'edit' ? ` ${palette.diffRemoved(`-${file.removed}`)}` : ''}`