@north-light/crouter 0.3.204 → 0.3.206

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

@@ -24,6 +24,8 @@ export interface BrokerErrorFrame {
  */
 export interface BrokerWelcomeSnapshot<M = unknown> {
     messages: M[];
+    /** Stable session-entry ids aligned 1:1 with `messages`. */
+    messageIds?: string[];
     state?: {
         isStreaming?: boolean;
     };

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

@@ -1,4 +1,14 @@
 import type { InboxTierDTO, IsoTime, NodeIdDTO } from './common.js';
+/** One runtime card supplied by a caller: the runtime renders and escapes it
+ *  exactly once, so a caller cannot emit a malformed card or smuggle markup
+ *  into one. `kind` must be namespaced (contain `:`) — bare kinds are
+ *  crouter's own closed vocabulary. */
+export interface RuntimeCardRequest {
+    kind: string;
+    facts?: Record<string, string | number>;
+    /** Data, not markup. */
+    body?: string;
+}
 /** `POST /v1/nodes/{id}/messages` body. */
 export interface SendMessageRequest {
     body: string;
@@ -16,6 +26,14 @@ export interface SendMessageRequest {
      *  a `<situational-context>` block, never visible chat (`--situational-context`).
      *  Immediate only; valid alone (no body). */
     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
+     *  bearings after a context refresh. Mutually exclusive with
+     *  `situational_context`; valid alone (no body) on the durable path. */
+    situational_card?: RuntimeCardRequest;
+    /** One-shot runtime cards for this turn only — never persisted. Delivered in
+     *  array order, after `situational_card` and ahead of the body. */
+    context_cards?: RuntimeCardRequest[];
     /** Raw JSON-schema string granting a one-off `submit` tool before delivery
      *  (`--output-schema`). Immediate only. */
     output_schema?: string;
@@ -24,7 +42,10 @@ export interface SendMessageRequest {
      *  instead of the durable inbox; a dormant or mid-revive target falls back to
      *  the durable inbox + revive (watcher delivers post-boot). Plain immediate
      *  body only — rejected with fresh/reopen/situational_context/
-     *  output_schema or tier 'deferred'. Absent → durable inbox (unchanged). */
+     *  output_schema or tier 'deferred'. Runtime cards ARE accepted: a
+     *  card-bearing send is an ordinary human send that happens to carry context,
+     *  and the live deliver frame places the cards ahead of the body in one turn.
+     *  Absent → durable inbox (unchanged). */
     delivery?: 'interactive';
 }
 /** Result of an immediate message send. */

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

@@ -5,12 +5,13 @@ export interface CreateNodeRequest {
     prompt?: string;
     profile?: string;
     mode?: ModeDTO;
-    /** The DIRECTORY CONTEXT the create came from — not necessarily where the
-     *  node lands. It is what the daemon selects a profile from when the request
-     *  neither names one nor inherits one from a parent. */
+    /** The directory the create came from. It is what the daemon selects a
+     *  profile from when the request neither names one nor inherits one from a
+     *  parent, and — for a node with no `pin_cwd` and no spawner to inherit from —
+     *  where the node lands. */
     cwd?: string;
-    /** Pin the node to this exact directory, overriding the profile home a node
-     *  otherwise runs in. See `crtr node new --cwd`. */
+    /** Pin the node to this exact directory, overriding both the spawner's
+     *  directory and the launch cwd. See `crtr node new --cwd`. */
     pin_cwd?: string;
     /** Display name (tmux window + resume picker). Defaults to the kind. */
     name?: string;
@@ -187,6 +188,8 @@ export interface NodeMessagesPageDTO {
     node_id: NodeIdDTO;
     /** pi AgentMessage[] JSON, chronological ascending within this page. */
     messages: unknown[];
+    /** Stable session-entry ids aligned 1:1 with `messages`. */
+    message_ids?: string[];
     /** Opaque cursor toward older messages; null at the start of the session. */
     next_cursor: Cursor | null;
     captured_at: IsoTime;

package/dist/api/index.d.ts

@@ -3,6 +3,7 @@ export type { CrtrClientOptions } from './client.js';
 export { ApiError, isErrorBody } from './errors.js';
 export type { ErrorBody } from './errors.js';
 export { API_VERSION, routes } from './routes.js';
+export * from '../shared/generated-context.js';
 export * from './dto/common.js';
 export * from './dto/health.js';
 export * from './dto/nodes.js';

package/dist/api/index.js

@@ -4,6 +4,7 @@
 export { CrtrClient } from './client.js';
 export { ApiError, isErrorBody } from './errors.js';
 export { API_VERSION, routes } from './routes.js';
+export * from '../shared/generated-context.js';
 export * from './dto/common.js';
 export * from './dto/health.js';
 export * from './dto/nodes.js';

package/dist/clients/attach/__tests__/context-message.test.js

@@ -1,22 +1,27 @@
 // Regression coverage for the attach viewer's display-only folding of
-// crouter-generated context. Two user-visible hazards are pinned here:
+// crouter-generated context. Three user-visible hazards are pinned here:
 //
 //   1. A folded row must never leak its body, and Ctrl+O must restore the full
 //      agent-visible content — the fold is display-only, so nothing is lost.
 //   2. A human message that merely reads like runtime recovery prose must NOT
 //      be classified as generated context; folding the user's own message away
 //      is the hazard that misclassification produces.
+//   3. An answer the person typed in their inbox renders as the person
+//      speaking, never as a runtime card.
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { Container } from '@earendil-works/pi-tui';
 import { applyTheme } from '../config.js';
 import { ChatView } from '../render/chat-view.js';
-import { CONTEXT_INTRO_CUSTOM_TYPE, CONTEXT_NUDGE_CUSTOM_TYPE, REVIVE_KICKOFF_SENTINEL, RUNTIME_RESTART_CONTINUATION, formatModelFallbackRecovery, formatReviewApproval, generatedContextPresentation, } from '../../../shared/generated-context.js';
+import { CONTEXT_INTRO_CUSTOM_TYPE, CONTEXT_NUDGE_CUSTOM_TYPE, formatCard, formatInboxCard, formatModelFallbackRecovery, parseCard, } from '../../../shared/generated-context.js';
 applyTheme();
+function chatView(container) {
+    const tui = { requestRender() { }, terminal: { rows: 40 } };
+    return new ChatView(tui, container, { toolOutputExpanded: false });
+}
 test('collapsed generated context never leaks its body; Ctrl+O restores it', async () => {
     const container = new Container();
-    const tui = { requestRender() { }, terminal: { rows: 40 } };
-    const view = new ChatView(tui, container, { toolOutputExpanded: false });
+    const view = chatView(container);
     const internals = view;
     internals.summarizeToolCalls = true;
     internals.foldSettledTools = true;
@@ -27,41 +32,71 @@ test('collapsed generated context never leaks its body; Ctrl+O restores it', asy
                 role: 'custom',
                 customType: CONTEXT_INTRO_CUSTOM_TYPE,
                 display: true,
-                content: '<auto-loaded-context>\nloaded INDEX.md content\n</auto-loaded-context>',
+                content: formatCard('bearings', {}, '<auto-loaded-context>\nloaded INDEX.md content\n</auto-loaded-context>'),
             },
-            { role: 'user', content: `${REVIVE_KICKOFF_SENTINEL}\n<yield-message>resume from this note</yield-message>` },
-            { role: 'user', content: RUNTIME_RESTART_CONTINUATION },
+            { role: 'user', content: formatCard('revive', {}, '<yield-message>resume from this note</yield-message>') },
+            { role: 'user', content: formatCard('restart-continuation', {}, 'private restart continuation') },
+            // Pre-envelope custom message from an old session: customType still classifies.
             {
                 role: 'custom',
                 customType: CONTEXT_NUDGE_CUSTOM_TYPE,
                 display: true,
                 content: '[crtr] Context ~150k. private context reminder',
             },
-            { role: 'user', content: 'From child-node-123 — 1 update:\n  [update] private inbox detail' },
-            { role: 'user', content: formatReviewApproval('The human reviewed and approved private-review.md.') },
+            {
+                role: 'user',
+                content: formatInboxCard([
+                    { id: 'child-node-123', name: 'child', entries: [{ kind: 'update', body: 'private inbox detail' }] },
+                ]),
+            },
+            { role: 'user', content: formatCard('review-approval', {}, 'The human reviewed and approved private-review.md.') },
         ],
         stats: {},
         state: { isStreaming: false },
     });
-    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|runtime-restart-continuation|private context reminder|private inbox detail|private-review\.md/);
+    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|private restart continuation|private context reminder|private inbox detail|private-review\.md/);
     assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: false });
     assert.equal(internals.toolOutputExpanded, true);
     const expanded = container.render(80).join('\n');
     assert.match(expanded, /loaded INDEX\.md content/);
     assert.match(expanded, /resume from this note/);
-    assert.doesNotMatch(expanded, /runtime-restart-continuation|private context reminder/);
+    assert.doesNotMatch(expanded, /private restart continuation|private context reminder/);
     assert.match(expanded, /private inbox detail/, 'an expanded inbox card shows the actual delivered update');
     assert.match(expanded, /private-review\.md/, 'an expanded review card shows the approval');
     assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: true });
     assert.equal(internals.toolOutputExpanded, false);
-    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|runtime-restart-continuation|private context reminder|private inbox detail/);
+    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|private restart continuation|private context reminder|private inbox detail/);
 });
 test('a human message that reads like runtime recovery is not folded as generated context', () => {
-    assert.equal(generatedContextPresentation({ role: 'user', content: 'continue' }), null, 'a human one-word continue is not mistaken for runtime recovery');
-    // The producer marker, not the prose, is what classifies a message. Strip the
-    // marker lines off a real recovery body and it must read as a human message.
-    const marked = formatModelFallbackRecovery('custom(provider)/model', 'new/model:high', 'not-found');
-    assert.equal(generatedContextPresentation({ role: 'user', content: marked })?.kind, 'recovery');
-    assert.equal(generatedContextPresentation({ role: 'user', content: marked.split('\n').slice(1, -1).join('\n') }), null, 'a human message matching the recovery prose lacks the producer marker');
-    assert.equal(generatedContextPresentation({ role: 'user', content: 'The human reviewed and approved private-review.md.' }), null, 'a human message matching the approval prose lacks the producer marker');
+    assert.equal(parseCard({ role: 'user', content: 'continue' }), null, 'a human one-word continue is not mistaken for runtime recovery');
+    // The producer's envelope, not the prose, is what classifies a message. Strip
+    // the envelope off a real recovery body and it must read as a human message.
+    const guidance = formatModelFallbackRecovery('custom(provider)/model', 'new/model:high', 'not-found');
+    const recovery = formatCard('recovery', { reason: 'model-fallback' }, guidance);
+    assert.equal(parseCard({ role: 'user', content: recovery })?.kind, 'recovery');
+    assert.equal(parseCard({ role: 'user', content: guidance }), null, 'a human message matching the recovery prose lacks the envelope');
+    assert.equal(parseCard({ role: 'user', content: 'The human reviewed and approved private-review.md.' }), null, 'a human message matching the approval prose lacks the envelope');
+});
+test("a person's inbox answer renders as their own message, not a runtime card", async () => {
+    const container = new Container();
+    const view = chatView(container);
+    await view.applySnapshot({
+        messages: [
+            {
+                role: 'user',
+                content: formatInboxCard([
+                    {
+                        id: 'human-ticket-node',
+                        name: 'human interaction',
+                        entries: [{ kind: 'final', disposition: 'human-answer', body: 'ship it on friday' }],
+                    },
+                ]),
+            },
+        ],
+        stats: {},
+        state: { isStreaming: false },
+    });
+    const rendered = container.render(80).join('\n');
+    assert.match(rendered, /ship it on friday/, "the person's words show without expanding anything");
+    assert.doesNotMatch(rendered, /crtr inbox|ctrl\+o/, 'an answer-only digest gets no card');
 });

package/dist/clients/attach/__tests__/page-block.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/page-block.test.js

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { atomicWriteJson, pageManifestPath, pagePath } from '../../../core/human/convention.js';
+import { derivePageManifestFromDocument } from '../../../core/human/page.js';
+import { sanitize } from '../../inbox/tui/ansi.js';
+import { PageBlockComponent } from '../render/page-block.js';
+function proposal(intro) {
+    return `const DOCS = ['Local stack', 'Guest home', 'Data and dependencies', 'Troubleshooting'];
+function Proposal({ docs }) {
+  return (
+    <Card>
+      <p>Move the <code>{docs.length}</code> operational areas behind focused pointers.</p>
+      <ul>{docs.map((doc) => <li key={doc}><strong>{doc}</strong> reference</li>)}</ul>
+    </Card>
+  );
+}
+export default function DevMemorySplit() {
+  return (
+    <Page title="Northlight dev memory" subtitle="Choose the documentation shape">
+      <p>${intro}</p>
+      <Proposal docs={DOCS} />
+      <UserQuestion id="decision" label="Approve the split?" body="The current file is 4,189 words." mode="single" options={[{ id: 'approve', label: 'Approve' }, { id: 'keep', label: 'Keep one file' }]} />
+    </Page>
+  );
+}
+`;
+}
+test('an inline page renders dynamic display JSX beside its manifest question and refreshes source-only revisions', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'crtr-page-block-'));
+    const source = proposal('The current guide mixes routing and operational detail.');
+    const manifest = derivePageManifestFromDocument(source);
+    writeFileSync(pagePath(dir), source);
+    atomicWriteJson(pageManifestPath(dir), manifest);
+    const block = new PageBlockComponent('dev-memory', dir, () => 'open it');
+    const rendered = sanitize(block.render(88).join('\n'));
+    assert.match(rendered, /The current guide mixes routing and operational detail\./);
+    assert.match(rendered, /Move the 4 operational areas behind focused pointers\./);
+    assert.match(rendered, /Local stack.*reference/);
+    assert.match(rendered, /Troubleshooting.*reference/);
+    assert.match(rendered, /Approve the split\?/);
+    assert.match(rendered, /The current file is 4,189 words\./);
+    assert.match(rendered, /Keep one file/);
+    const revised = proposal('The replacement keeps the intent router short.');
+    writeFileSync(pagePath(dir), revised);
+    const future = new Date(Date.now() + 2_000);
+    utimesSync(pagePath(dir), future, future);
+    assert.equal(block.refresh(), true);
+    const refreshed = sanitize(block.render(88).join('\n'));
+    assert.match(refreshed, /The replacement keeps the intent router short\./);
+    assert.doesNotMatch(refreshed, /mixes routing and operational detail/);
+});

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

@@ -245,6 +245,9 @@ export declare class ChatView {
     private appendAssistantSeparator;
     private appendAssistantPart;
     private appendUserPart;
+    /** An answer the person typed in their inbox renders exactly like a message
+     * they typed here, and closes the run around it the same way. */
+    private appendHumanAnswer;
     /** Only the full-fidelity trailing region gets summary groups. Condensed
      * history intentionally drops tool traffic, so grouping there would create
      * phantom summary rows and cross the live/condensed boundary. */

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

@@ -23,11 +23,11 @@
 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 } from './context-message.js';
+import { ContextMessageComponent, contextCardBody, expandsWithTools } from './context-message.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 { generatedContextExpandedBody, generatedContextPresentation, isRuntimeRestartContinuation, } from '../../../shared/generated-context.js';
+import { parseCard } from '../../../shared/generated-context.js';
 import { assistantVisibleText, isTrueUserMessage, } from '../../../shared/tool-groups.js';
 import { transformDiagramFences } from './diagram.js';
 import { styleAttachAgentMarkdown, styleAttachMarkdownSource, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-source.js';
@@ -167,6 +167,9 @@ function stripBackground(line) {
         return kept.length > 0 ? `\x1b[${kept.join(';')}m` : '';
     });
 }
+/** Sender sections of an inbox card body; `parseCard` already read their entries.
+ * Whatever remains is other content riding the same digest. */
+const INBOX_SENDER_SECTIONS = /<from\b[^>]*>[\s\S]*?<\/from>/g;
 /** A tool component that can fold itself down to its CALL. pi's `ToolExecutionComponent`
  *  only knows expanded/collapsed, so each crtr-owned definition receives a local fold
  *  controller and captures the compact call component it renders. Folded render paints
@@ -1024,33 +1027,49 @@ export class ChatView {
     addMessageToChat(message) {
         // Crouter-generated context retains its runtime role (user vs custom) so
         // delivery to the model is unchanged, but every attached view presents it
-        // through one compact disclosure contract. The shared classifier uses the
-        // producers' exact custom types/sentinels, so ordinary user prompts cannot
-        // accidentally acquire this treatment and saved transcripts gain it too.
-        const generated = generatedContextPresentation(message);
-        if (generated !== null &&
+        // through one compact disclosure contract. The producer's envelope is what
+        // classifies, so an ordinary user prompt cannot acquire this treatment and
+        // saved transcripts gain it too.
+        const card = parseCard(message);
+        if (card !== null &&
             (message.role !== 'custom' || message.display === true)) {
-            this.pushTranscriptText(generated.body);
-            const component = new ContextMessageComponent(generatedContextExpandedBody(generated), this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), generated.label, ` ${generated.summary} — ctrl+o to expand`, generated.label === 'crtr context' || generated.kind === 'revive' || generated.kind === 'inbox' || generated.kind === 'review-approval');
-            // 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 (isRuntimeRestartContinuation(message)) {
-                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 (generated.kind === 'bearings' || generated.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 (generated.kind === 'inbox')
-                    group?.activity.noteInboxDigest(generated.body);
+            this.pushTranscriptText(card.body);
+            // A person's inbox answer is the person speaking: their words leave the
+            // card and render as their own message. A digest carrying nothing else
+            // gets no card at all — but a passive backlog folded into the same body
+            // is content, so the residue check keeps it from vanishing with the card.
+            const answers = card.senders
+                .flatMap((sender) => sender.entries)
+                .filter((entry) => entry.disposition === 'human-answer')
+                .map((entry) => entry.body.trim())
+                .filter((text) => text !== '');
+            const onlyHumanWords = answers.length > 0
+                && 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') {
+                    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);
+                }
             }
+            for (const answer of answers)
+                this.appendHumanAnswer(answer);
             return;
         }
         switch (message.role) {
@@ -1193,6 +1212,16 @@ export class ChatView {
         else
             this.append(component);
     }
+    /** An answer the person typed in their inbox renders exactly like a message
+     * they typed here, and closes the run around it the same way. */
+    appendHumanAnswer(text) {
+        this.closeOpenGroup();
+        if (this.chatChildCount() > 0)
+            this.append(new Spacer(1));
+        const component = new UserMessageComponent(text, attachMarkdownTheme(), undefined, this.markdownTransformers);
+        this.append(component);
+        this.registerCopyBlock(component, 'user', text);
+    }
     /** Only the full-fidelity trailing region gets summary groups. Condensed
      * history intentionally drops tool traffic, so grouping there would create
      * phantom summary rows and cross the live/condensed boundary. */

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

@@ -1,4 +1,10 @@
 import { type Component } from '@earendil-works/pi-tui';
+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;

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

@@ -5,9 +5,9 @@
 // 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 and disclosure
-// selection live in shared/generated-context.ts; this component only renders
-// the presentation it is handed.
+// 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.
 import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { attachMarkdownTheme } from '../config.js';
@@ -15,6 +15,24 @@ 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;

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

@@ -1,3 +1,4 @@
+import type { GeneratedCard } from '../../../shared/generated-context.js';
 export type FileActivity = {
     key: string;
     displayPath: string;
@@ -38,9 +39,10 @@ export declare class GroupActivityRecorder {
     /** `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 digest names senders
-     * by node id, so the spawn roster supplies the display name when it has one. */
-    noteInboxDigest(body: string): void;
+    /** 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;
     noteCall(id: string, name: string, args: unknown): void;
     settle(id: string, result: unknown, isError: boolean): void;
     resolveWithoutResult(id: string): void;

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

@@ -3,7 +3,6 @@
 // calls into the exact evidence already present in the session transcript.
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { inboxFinishedSenders } from '../../../shared/generated-context.js';
 import { countDisplayDiffLines } from './edit-diff.js';
 const EMPTY_ACTIVITY = Object.freeze({
     files: Object.freeze([]),
@@ -162,11 +161,16 @@ export class GroupActivityRecorder {
         this.cwd = cwd;
         this.roster = roster;
     }
-    /** Record the nodes an inbox digest reports finished. The digest names senders
-     * by node id, so the spawn roster supplies the display name when it has one. */
-    noteInboxDigest(body) {
-        for (const id of inboxFinishedSenders(body)) {
-            this.addNode({ action: 'finished', name: this.roster.get(id) ?? id, id });
+    /** 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 });
         }
     }
     noteCall(id, name, args) {

package/dist/clients/attach/render/page-block.js

@@ -11,9 +11,10 @@
 // result text, so `--replace` revisions and the answer that settles a page both
 // land on the already-placed block when `refresh()` is driven by the viewer's
 // inbox-activity watcher.
-import { statSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
+import { projectPageDisplayMarkdown } from '../../../core/human/page-markdown.js';
 import { parsePage } from '../../../core/human/page.js';
-import { pageManifestPath, responsePath } from '../../../core/human/convention.js';
+import { pageManifestPath, pagePath, responsePath } from '../../../core/human/convention.js';
 import { pageTicketState, readTicketResult } from '../../../core/human/tickets.js';
 import { renderMarkdownBlockAwareLines } from '../../../core/termrender/termrender.js';
 import { describeSlot, tableMarkdown, terminalAnswerable } from '../../inbox/tui/slots.js';
@@ -101,7 +102,7 @@ export class PageBlockComponent {
         this.cache = undefined;
     }
     diskStamp() {
-        return `${mtimeOf(pageManifestPath(this.dir))}|${mtimeOf(responsePath(this.dir))}`;
+        return `${mtimeOf(pageManifestPath(this.dir))}|${mtimeOf(pagePath(this.dir, 'jsx'))}|${mtimeOf(pagePath(this.dir, 'html'))}|${mtimeOf(responsePath(this.dir))}`;
     }
     reload() {
         this.stamp = this.diskStamp();
@@ -109,10 +110,14 @@ export class PageBlockComponent {
         this.cache = undefined;
         try {
             const manifest = parsePage(this.dir);
+            const displayMarkdown = manifest.dialect === 'jsx'
+                ? projectPageDisplayMarkdown(readFileSync(pagePath(this.dir, 'jsx'), 'utf8'), manifest)
+                : '';
             const state = pageTicketState(this.dir);
             const digest = state === 'resolved' ? readTicketResult(this.dir) : null;
             this.snapshot = {
                 manifest,
+                displayMarkdown,
                 state,
                 ...(digest?.kind === 'page' ? { answerDigest: digest.summary.replace(/\s+/g, ' ').trim() } : {}),
             };
@@ -134,7 +139,7 @@ export class PageBlockComponent {
             for (const line of wrap(sanitize(snapshot.manifest.subtitle), maxW))
                 out.push(`  ${DIM}${line}${RESET}`);
         }
-        const body = this.bodyLines(snapshot.manifest, maxW, Math.max(20, width - 4));
+        const body = this.bodyLines(snapshot.manifest, snapshot.displayMarkdown, maxW, Math.max(20, width - 4));
         if (body.length > 0) {
             out.push('');
             const shown = this.expanded || body.length <= FOLDED_BODY_LINES ? body : body.slice(0, FOLDED_BODY_LINES);
@@ -149,16 +154,11 @@ export class PageBlockComponent {
         out.push('');
         return out;
     }
-    bodyLines(manifest, maxW, paneW) {
+    bodyLines(manifest, displayMarkdown, maxW, paneW) {
         const md = (text) => renderMarkdownBlockAwareLines(text, maxW, paneW);
         if (manifest.dialect === 'html')
             return [`${DIM}HTML page — opens in a browser surface${RESET}`];
-        // Display components (Card, Alert, the rest of the shadcn set) are page markup,
-        // not manifest slots, so a page built only from them keeps nothing here a
-        // terminal could draw. Say so rather than paint a title over an empty body.
-        if (manifest.slots.length === 0)
-            return [`${DIM}display-only page — its content renders in Northlight${RESET}`];
-        const lines = [];
+        const lines = displayMarkdown === '' ? [] : md(displayMarkdown);
         let priorStep = -1;
         for (const slot of manifest.slots) {
             if (manifest.steps > 1 && slot.step !== priorStep) {