@north-light/crouter 0.3.203 → 0.3.205

package/dist/core/runtime/session-cycles.js

@@ -14,7 +14,7 @@
 // boundary, then the live cycle's context — so the broker welcome snapshot
 // (broker.ts) and the dormant snapshot (node-snapshot.ts) both render one
 // continuous conversation.
-import { buildSessionContext } from '@earendil-works/pi-coding-agent';
+import { buildContextEntries, sessionEntryToContextMessages, } from '@earendil-works/pi-coding-agent';
 /** customType of the persisted tree entry that ROOTS each post-yield cycle.
  *  Data payload: `{ cycle, fromLeaf }` — `cycle` is the node's cycle counter at
  *  relaunch, `fromLeaf` the previous cycle's leaf entry id. */
@@ -55,9 +55,14 @@ export function withoutYieldAbort(message) {
     const { stopReason: _stopReason, errorMessage: _errorMessage, ...visible } = message;
     return visible;
 }
+function identifiedContextMessages(entries, leafId, byId) {
+    return buildContextEntries(entries, leafId, byId).flatMap((entry) => sessionEntryToContextMessages(entry).map((message) => ({ id: entry.id, message: message })));
+}
 function priorCycleMessages(messages) {
     const last = messages.at(-1);
-    return last === undefined ? messages : [...messages.slice(0, -1), withoutYieldAbort(last)];
+    return last === undefined
+        ? messages
+        : [...messages.slice(0, -1), { ...last, message: withoutYieldAbort(last.message) }];
 }
 /** The full multi-cycle message history for display: prior cycles (oldest
  *  first, each closed by a divider), then the live cycle's context. Falls back
@@ -66,11 +71,13 @@ function priorCycleMessages(messages) {
  *  tree-navigated back into a pre-yield branch (pi's active-branch semantics
  *  then apply unchanged). */
 export function cycleAwareMessages(sm) {
-    const current = sm.buildSessionContext().messages;
     if (typeof sm.getEntries !== 'function' || typeof sm.getBranch !== 'function')
-        return current;
+        return undefined;
     // File order = append order = chronological cycle order.
     const entries = sm.getEntries();
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const currentBranch = sm.getBranch();
+    const current = identifiedContextMessages(entries, currentBranch.at(-1)?.id ?? null, byId);
     const markers = entries.filter((e) => e.type === 'custom' && e.customType === CRTR_CYCLE_CUSTOM_TYPE);
     if (markers.length === 0)
         return current;
@@ -78,14 +85,10 @@ export function cycleAwareMessages(sm) {
     // not a cycle marker, the leaf sits in the ORIGINAL (pre-yield) branch —
     // render just that branch. Otherwise replay every cycle up to and including
     // the one the marker closes.
-    const currentRootId = sm.getBranch()[0]?.id;
+    const currentRootId = currentBranch[0]?.id;
     const rootMarkerIndex = markers.findIndex((m) => m.id === currentRootId);
     if (rootMarkerIndex === -1)
         return current;
-    // Shared byId map — buildSessionContext would otherwise rebuild one from
-    // `entries` on every call; one pass here amortizes it across every replayed
-    // marker.
-    const byId = new Map(entries.map((e) => [e.id, e]));
     const out = [];
     for (let i = 0; i <= rootMarkerIndex; i++) {
         const marker = markers[i];
@@ -95,9 +98,12 @@ export function cycleAwareMessages(sm) {
             // builder — preserving compaction semantics (one compactionSummary +
             // kept + post-compaction messages only) exactly like the live cycle
             // below.
-            out.push(...priorCycleMessages(buildSessionContext(entries, fromLeaf, byId).messages));
+            out.push(...priorCycleMessages(identifiedContextMessages(entries, fromLeaf, byId)));
         }
-        out.push(cycleDivider(marker.data?.cycle, marker.timestamp));
+        out.push({
+            id: `${marker.id}~divider`,
+            message: cycleDivider(marker.data?.cycle, marker.timestamp),
+        });
     }
     out.push(...current);
     return out;

package/dist/core/runtime/session-visibility.d.ts

@@ -1,16 +1,11 @@
-import type { BrokerSnapshot, WireSessionTreeNode } from './broker-protocol.js';
-/** customType of the crtr-authored boundary marker that opens a review
- *  companion's visible transcript. Data payload: `{ reviewId, originNodeId,
- *  targetFile }` — per-review facts that complement the inheritance prefix.
- *
- *  The marker itself is a crtr-rendered divider shown to the person; everything
- *  above it in the inherited session is context they cannot see.
- */
-export declare const REVIEW_BOUNDARY_CUSTOM_TYPE = "crtr-review-boundary";
+import type { WireSessionTreeNode } from './broker-protocol.js';
+import type { IdentifiedMessage } from './session-cycles.js';
+import { REVIEW_BOUNDARY_CUSTOM_TYPE } from '../../shared/generated-context.js';
+export { REVIEW_BOUNDARY_CUSTOM_TYPE };
 /** True when an entry is a durable review boundary, optionally for one review. */
 export declare function isReviewBoundary(entry: unknown, reviewId?: string): boolean;
 /**
- * Project snapshot messages to the visible window for a review companion.
+ * Project identified snapshot messages to the visible window for a review companion.
  *
  * A companion passes its binding's review id so the slice starts at ITS OWN
  * boundary marker: a node forked from another companion inherits that
@@ -27,9 +22,9 @@ export declare function isReviewBoundary(entry: unknown, reviewId?: string): boo
  *    with a synthetic boundary while its retained tail remains visible. Every
  *    other markerless shape fails closed with the synthetic boundary alone.
  */
-export declare function visibleMessages(messages: BrokerSnapshot['messages'], opts: {
+export declare function visibleMessages(messages: IdentifiedMessage[], opts: {
     boundaryReviewId: string | undefined;
-}): BrokerSnapshot['messages'];
+}): IdentifiedMessage[];
 /**
  * Project a session tree to the review companion's visible transcript boundary.
  *

package/dist/core/runtime/session-visibility.js

@@ -9,14 +9,8 @@
 // Applied at the two BrokerSnapshot.messages producers (live broker and
 // dormant node read) so every presenter — attach, web node viewer, inspect — is
 // boundary-safe by construction with no presenter-side changes.
-/** customType of the crtr-authored boundary marker that opens a review
- *  companion's visible transcript. Data payload: `{ reviewId, originNodeId,
- *  targetFile }` — per-review facts that complement the inheritance prefix.
- *
- *  The marker itself is a crtr-rendered divider shown to the person; everything
- *  above it in the inherited session is context they cannot see.
- */
-export const REVIEW_BOUNDARY_CUSTOM_TYPE = 'crtr-review-boundary';
+import { REVIEW_BOUNDARY_CUSTOM_TYPE } from '../../shared/generated-context.js';
+export { REVIEW_BOUNDARY_CUSTOM_TYPE };
 /** True when an entry is a durable review boundary, optionally for one review. */
 export function isReviewBoundary(entry, reviewId) {
     if (entry === null || typeof entry !== 'object')
@@ -36,7 +30,7 @@ function syntheticBoundary(timestamp) {
     };
 }
 /**
- * Project snapshot messages to the visible window for a review companion.
+ * Project identified snapshot messages to the visible window for a review companion.
  *
  * A companion passes its binding's review id so the slice starts at ITS OWN
  * boundary marker: a node forked from another companion inherits that
@@ -54,16 +48,16 @@ function syntheticBoundary(timestamp) {
  *    other markerless shape fails closed with the synthetic boundary alone.
  */
 export function visibleMessages(messages, opts) {
-    const markerIndex = messages.findIndex((message) => isReviewBoundary(message, opts.boundaryReviewId));
+    const markerIndex = messages.findIndex(({ message }) => isReviewBoundary(message, opts.boundaryReviewId));
     if (markerIndex !== -1)
         return messages.slice(markerIndex);
     if (opts.boundaryReviewId === undefined)
         return messages;
     const [first, ...retainedTail] = messages;
-    if (first?.role === 'compactionSummary') {
-        return [syntheticBoundary(first.timestamp), ...retainedTail];
+    if (first?.message.role === 'compactionSummary') {
+        return [{ id: '~boundary', message: syntheticBoundary(first.message.timestamp) }, ...retainedTail];
     }
-    return [syntheticBoundary(first?.timestamp)];
+    return [{ id: '~boundary', message: syntheticBoundary(first?.message.timestamp) }];
 }
 /**
  * Project a session tree to the review companion's visible transcript boundary.

package/dist/core/runtime/situational-live.js

@@ -16,6 +16,7 @@
 // (`deliver-live.ts`), which the claim's bearings delivery also rides.
 import { getNode } from '../canvas/index.js';
 import { deliverCustomMessageLive } from './deliver-live.js';
+import { formatCard } from '../../shared/generated-context.js';
 import { appendSituationalContext, situationalContextBlock, SITUATIONAL_CONTEXT_CUSTOM_TYPE, } from './situational-context.js';
 /** Write `text` to the node's sidecar and, when its broker is live, deliver the
  *  rendered block into the running session for the NEXT turn.
@@ -34,7 +35,7 @@ export async function setSituationalContextLive(nodeId, text) {
         return; // blank text — appendSituationalContext no-ops, nothing to deliver
     await deliverCustomMessageLive(nodeId, {
         customType: SITUATIONAL_CONTEXT_CUSTOM_TYPE,
-        content: block,
+        content: formatCard('situational', {}, block),
         deliverAs: 'nextTurn',
     });
 }

package/dist/core/runtime/stop-guard.js

@@ -23,16 +23,16 @@
 //                      final pushed. Re-prompt it to finish or escalate.
 import { hasActiveLiveSubscription, hasLiveMessageWait, hasPendingCancelOnWakeCron, getNode, contextDir } from '../canvas/index.js';
 import { activeBackgroundBashJobs } from '../bash-jobs.js';
-import { formatStructuredOutputReprompt, STALL_REPROMPT } from '../../shared/generated-context.js';
+import { formatCard, formatStructuredOutputReprompt, STALL_REPROMPT } from '../../shared/generated-context.js';
 import { readOutputRequest } from './structured-output.js';
 export { STALL_REPROMPT } from '../../shared/generated-context.js';
 /** Format the stop guard's reprompt for a valid structured-output request. */
 function formatValidStructuredOutputReprompt(schema) {
-    return formatStructuredOutputReprompt(JSON.stringify(schema, null, 2));
+    return formatCard('stop-guard', { reason: 'structured-output' }, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
 }
 /** Format the stop guard's reprompt for an invalid structured-output request file. */
 function formatInvalidStructuredOutputReprompt(error) {
-    return (`Structured-output request file is invalid and cannot be used: ${error}\n\n` +
+    return formatCard('stop-guard', { reason: 'structured-output' }, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
         `You have two options:\n` +
         `1. Remove the invalid file (the output-schema.json in your node directory has been corrupted)\n` +
         `2. Fix the corruption if you know the original request schema\n\n` +
@@ -96,5 +96,9 @@ export function evaluateStop(nodeId, signals, backgroundJobsRunning = activeBack
         || backgroundJobsRunning)
         return { action: 'allow', reason: 'awaiting' };
     // A terminal node with nothing live and no final pushed has stalled.
-    return { action: 'reprompt', reason: 'stalled', message: STALL_REPROMPT };
+    return {
+        action: 'reprompt',
+        reason: 'stalled',
+        message: formatCard('stop-guard', { reason: 'stalled' }, STALL_REPROMPT),
+    };
 }

package/dist/core/runtime/warm-pool.d.ts

@@ -17,7 +17,7 @@ export interface WarmRequest {
     kind: string;
     mode: Mode;
     /** Where the node runs — already resolved by the create handler (pin >
-     *  spawner > profile home), never a raw caller directory. */
+     *  spawner > launch cwd > profile home). */
     cwd: string;
     /** The RESOLVED profile id, or null for explicitly no profile. */
     profileId: string | null;

package/dist/core/runtime/warm-pool.js

@@ -47,10 +47,9 @@
 // and at daemon start for the most recently used profiles, so the FIRST node
 // after sitting down is warm too.
 //
-// The pool does not fan out per directory: a node runs in its profile's home
-// (`resolveNodeCwd` in the create handler), so the cwd a spare freezes is a
-// function of its profile, and "which spare serves this create" is in practice
-// a question about the profile alone.
+// A spare freezes the directory it was booted in, so a create launched from a
+// different directory than the last one simply misses and cold-spawns — the
+// pool serves the common case of returning to the same working directory.
 //
 // Nothing ever RESUMES a spare: the daemon's recovery sweep reads `listNodes`,
 // which hides the pool, so a spare whose broker dies (every daemon handover
@@ -63,7 +62,6 @@ import { claimWarmSpare, deleteNode, getNode, listNodes, listWarmSpares, registe
 import { recordedPidLiveness } from '../canvas/pid.js';
 import { nowIso } from '../fs-utils.js';
 import { spawnChildPrepared } from './spawn.js';
-import { profileHome } from '../profiles/manifest.js';
 import { buildLaunchSpec } from './launch.js';
 import { setModelLive } from './model-swap.js';
 import { setSituationalContextLive } from './situational-live.js';
@@ -335,10 +333,9 @@ export function prewarmRecentRecipes() {
             if (seen.has(profileId ?? ''))
                 continue;
             seen.add(profileId ?? '');
-            // The profile's home is where its next node will land. A profile without
-            // one (root, or a home since deleted) still gets a spare, keyed on the
-            // directory its last root actually ran in.
-            candidates.push({ cwd: profileHome(profileId) ?? row.cwd, profileId });
+            // A node lands in the directory its launch names, so the profile's last
+            // root predicts the next one better than the profile's home does.
+            candidates.push({ cwd: row.cwd, profileId });
             if (candidates.length >= PREWARM_PROFILES)
                 break;
         }

package/dist/daemon/api/handlers/nodes.js

@@ -98,14 +98,14 @@ function parseCreateBody(body) {
 }
 /** The directory a new node is pinned to. An explicit `pin_cwd` wins; else a
  *  managed child inherits its spawner's cwd (which is what keeps a worktree
- *  node's whole subtree inside that worktree); else the node runs in its
- *  profile's home. The request's own `cwd` — the caller's directory — is only
- *  the last resort, for a profile that has no home (notably root).
+ *  node's whole subtree inside that worktree); else the launch's own `cwd`, the
+ *  directory the create came from; else the profile's home.
  *
- *  This is the profile→cwd direction: `cwd` selected the profile a moment ago,
- *  and the profile now supplies where the node runs. Collapsing every create
- *  under a profile onto one directory is also what keeps the warm pool to one
- *  spare per profile instead of one per directory anyone happened to spawn from. */
+ *  The launch directory beating the profile home is what lets one profile cover
+ *  many working directories — a root started inside a planted instance runs in
+ *  that instance while still taking its identity, purview, and memory from the
+ *  profile covering it. The profile supplies a home only for a create that named
+ *  no directory at all. */
 function resolveNodeCwd(req, parent, profileId, contextCwd) {
     if (req.pin_cwd !== undefined && req.pin_cwd !== '')
         return resolve(req.pin_cwd);
@@ -114,6 +114,8 @@ function resolveNodeCwd(req, parent, profileId, contextCwd) {
         if (spawner !== null)
             return spawner.cwd;
     }
+    if (req.cwd !== undefined && req.cwd !== '')
+        return resolve(req.cwd);
     return profileHome(profileId) ?? contextCwd;
 }
 /** Build the immediate spawn recipe. */
@@ -328,6 +330,7 @@ async function handleMessages(ctx) {
     const body = {
         node_id: id,
         messages: read.messages,
+        ...(read.messageIds === undefined ? {} : { message_ids: read.messageIds }),
         next_cursor: read.nextCursor,
         captured_at: nowIso(),
     };

package/dist/daemon/companion-retire.d.ts

@@ -1,2 +1,2 @@
-/** Retire a companion only through a lifecycle transition legal for its current status. */
-export declare function retireCompanion(nodeId: string, outcome: 'approved' | 'canceled'): 'retired' | 'already' | 'missing';
+/** Retire a companion only through the terminal transition legal for its current status. */
+export declare function retireCompanion(nodeId: string, outcome: 'approved' | 'canceled'): Promise<'retired' | 'already' | 'missing'>;

package/dist/daemon/companion-retire.js

@@ -3,25 +3,32 @@
 // can retire a feedback companion without importing the review finisher (which
 // itself imports human/finish.ts).
 import { getNode } from '../core/canvas/canvas.js';
+import { FinalizationError, pushFinal } from '../core/feed/feed.js';
 import { transition } from '../core/runtime/lifecycle.js';
 import { headlessBrokerHost } from '../core/runtime/host.js';
-/** Retire a companion only through a lifecycle transition legal for its current status. */
-export function retireCompanion(nodeId, outcome) {
+/** Retire a companion only through the terminal transition legal for its current status. */
+export async function retireCompanion(nodeId, outcome) {
     const node = getNode(nodeId);
     if (node === null)
         return 'missing';
-    if (node.status === 'done' || node.status === 'canceled')
+    if (node.status === 'canceled' || (outcome === 'canceled' && node.status === 'done'))
         return 'already';
-    if (outcome === 'approved' && (node.status === 'active' || node.status === 'idle')) {
-        transition(nodeId, 'finish');
+    if (outcome === 'approved' && (node.status === 'active' || node.status === 'idle' || node.status === 'done')) {
+        let result = 'retired';
+        try {
+            await pushFinal(nodeId, 'The companion conversation is complete.');
+        }
+        catch (error) {
+            if (!(error instanceof FinalizationError) || error.code !== 'already_finalized')
+                throw error;
+            result = 'already';
+        }
         try {
             headlessBrokerHost.teardown(nodeId);
         }
-        catch { /* the terminal transition is authoritative */ }
-        return 'retired';
+        catch { /* the canonical final is authoritative */ }
+        return result;
     }
-    // Cancellation is legal from every status. An already-dead companion cannot
-    // be finished, so it is retired as canceled even when approval won.
     transition(nodeId, 'cancel');
     if (node.status === 'active' || node.status === 'idle') {
         try {

package/dist/daemon/human/finish.d.ts

@@ -1,10 +1,10 @@
 import type { TicketResult } from '../../core/human/types.js';
 /** Every ticket-ending action retires the ticket's feedback companion — done
- * when active or idle, never left resident. Idempotent and replay-safe; a
+ * with a canonical final when approved, never left resident. Idempotent and replay-safe; a
  * corrupt feedback file must not block result publication. Exported for the
  * daemon-start sweep, which must settle terminal tickets whether or not a
  * reply bridge exists. */
-export declare function settleFeedbackCompanion(ticketId: string): void;
+export declare function settleFeedbackCompanion(ticketId: string, outcome: 'approved' | 'canceled'): Promise<void>;
 /**
  * The one completion path for a page ticket: claim takeover, exclusive result
  * publication, then optional reply delivery. Every addressing surface routes

package/dist/daemon/human/finish.js

@@ -9,20 +9,20 @@ import { pagePath, readTicketReplyRoute, responsePath } from '../../core/human/c
 import { readPageFeedback } from '../../core/human/feedback.js';
 import { pageDocumentSha256 } from '../../core/human/feedback-companion.js';
 import { appendInbox } from '../../core/feed/inbox.js';
-import { FinalDeliveryError, pushFinal } from '../../core/feed/feed.js';
+import { FinalDeliveryError, pushFinal, pushUpdate } from '../../core/feed/feed.js';
 import { transition } from '../../core/runtime/lifecycle.js';
 import { emitEvent } from '../../core/events/emit.js';
 import { retireCompanion } from '../companion-retire.js';
 /** Every ticket-ending action retires the ticket's feedback companion — done
- * when active or idle, never left resident. Idempotent and replay-safe; a
+ * with a canonical final when approved, never left resident. Idempotent and replay-safe; a
  * corrupt feedback file must not block result publication. Exported for the
  * daemon-start sweep, which must settle terminal tickets whether or not a
  * reply bridge exists. */
-export function settleFeedbackCompanion(ticketId) {
+export async function settleFeedbackCompanion(ticketId, outcome) {
     try {
         const companionNodeId = readPageFeedback(ticketDir(ticketId)).companionNodeId;
         if (companionNodeId !== undefined)
-            retireCompanion(companionNodeId, 'approved');
+            await retireCompanion(companionNodeId, outcome);
     }
     catch (error) {
         emitEvent({ level: 'warn', event: 'human.feedback_companion.retire_failed', error });
@@ -80,15 +80,51 @@ function pageTitle(dir) {
         return undefined;
     }
 }
+/** Person-authored response values, derived from the structured answer rather
+ * than display prose. Empty values have no words to attribute. */
+function personWords(answer) {
+    if (answer.kind === 'acknowledgement')
+        return '';
+    const words = [];
+    for (const slot of answer.slots) {
+        if (slot.state !== 'answered')
+            continue;
+        if (slot.raw !== undefined) {
+            words.push(JSON.stringify(slot.raw));
+            continue;
+        }
+        if (slot.text !== undefined) {
+            if (slot.text.edited || slot.text.singleLine === true)
+                words.push(slot.text.value);
+            continue;
+        }
+        for (const group of slot.groups)
+            words.push(...group.picked.map((item) => item.label));
+        if (slot.freetext !== undefined)
+            words.push(slot.freetext);
+        words.push(...slot.comments.map((comment) => comment.text));
+    }
+    return words.filter((word) => word !== '').join('\n\n');
+}
+/** The answer push: the person's words alone when the page captured any, tagged
+ * so every reader attributes them to the person without re-deriving it from
+ * prose. A page that captured nothing stays an ordinary report carrying the
+ * full record, because there is nothing of the person's to attribute. */
 function renderPageAnswer(dir, result, resultPath) {
     let manifest;
     try {
         manifest = parsePage(dir);
     }
     catch {
-        return renderCorruptPageAnswer(result, resultPath);
+        return { body: renderCorruptPageAnswer(result, resultPath) };
     }
-    return renderAnswerText(describePageAnswer(manifest, result.responses, { completedAt: result.completedAt }), resultPath) + feedbackAddendum(dir);
+    const answer = describePageAnswer(manifest, result.responses, { completedAt: result.completedAt });
+    const rendered = renderAnswerText(answer, resultPath);
+    const addendum = feedbackAddendum(dir);
+    const words = personWords(answer);
+    return words === ''
+        ? { body: rendered + addendum }
+        : { body: words, disposition: 'human-answer', ...(addendum === '' ? {} : { feedback: addendum.trim() }) };
 }
 function deliveryFailed(error) {
     // A canonical final is committed inside its own write boundary and can never
@@ -155,7 +191,7 @@ export async function deliverTerminalResult(ticketId) {
     // through here, and an inbox-only page with no reply bridge still settles
     // its companion. The daemon-start sweep settles the tickets that die before
     // reaching this call.
-    settleFeedbackCompanion(ticketId);
+    await settleFeedbackCompanion(ticketId, result.kind === 'canceled' ? 'canceled' : 'approved');
     const replyRoute = readTicketReplyRoute(dir);
     if (replyRoute === null)
         return false;
@@ -198,6 +234,7 @@ export async function deliverTerminalResult(ticketId) {
                     kind: 'message',
                     label: subject,
                     data: { body },
+                    disposition: 'human-canceled',
                 });
             }
             catch {
@@ -210,7 +247,10 @@ export async function deliverTerminalResult(ticketId) {
         return true;
     }
     if (result.kind === 'page') {
-        await pushFinal(bridgeNodeId, renderPageAnswer(dir, result, responsePath(dir)));
+        const answer = renderPageAnswer(dir, result, responsePath(dir));
+        if (answer.feedback !== undefined)
+            await pushUpdate(bridgeNodeId, answer.feedback);
+        await pushFinal(bridgeNodeId, answer.body, answer.disposition === undefined ? undefined : { disposition: answer.disposition });
     }
     return true;
 }

package/dist/daemon/human/sweep.js

@@ -21,7 +21,8 @@ export async function reconcileUndeliveredTickets() {
             if (!statSync(dir).isDirectory())
                 continue;
             scanned += 1;
-            if (readTicketResult(dir) === null)
+            const ticketResult = readTicketResult(dir);
+            if (ticketResult === null)
                 continue;
             // Canonical reviews own terminal delivery and bridge retirement. Their
             // finisher retries only when its winning operation is explicitly repeated.
@@ -30,7 +31,7 @@ export async function reconcileUndeliveredTickets() {
             // A terminal page ticket retires its feedback companion whether or not a
             // reply bridge exists: inbox-only pages have no bridge row, yet the
             // daemon can die between result publication and companion retirement.
-            settleFeedbackCompanion(entry);
+            await settleFeedbackCompanion(entry, ticketResult.kind === 'canceled' ? 'canceled' : 'approved');
             // The ROW is what carries status; `getNode` would answer from a pruned
             // bridge's surviving meta.json with no status at all.
             const bridge = getRow(entry);

package/dist/daemon/messaging/node-message.d.ts

@@ -4,6 +4,10 @@ export interface NodeMessageDelivery {
     via: 'engine' | 'inbox';
     revived: boolean;
 }
+export interface RuntimeMessageCard {
+    kind: string;
+    facts: Record<string, string | number | boolean | undefined>;
+}
 /**
  * Deliver one daemon-originated node message. Interactive messages use the live
  * broker when available; every other successful path is a durable inbox entry.
@@ -15,4 +19,5 @@ export declare function deliverNodeMessage(args: {
     from?: string | null;
     mode: NodeMessageMode;
     data?: Record<string, unknown>;
+    runtime?: RuntimeMessageCard;
 }): Promise<NodeMessageDelivery>;

package/dist/daemon/messaging/node-message.js

@@ -7,6 +7,7 @@ import { isBrokerLive } from '../../core/runtime/model-swap.js';
 import { reviveNode } from '../../core/runtime/revive.js';
 import { hasNoNaturalCycle } from '../../core/runtime/revive-all.js';
 import { ReviewOperationError } from '../../core/review/types.js';
+import { formatCard } from '../../shared/generated-context.js';
 function deliveryUnroutable(nodeId, reason) {
     throw new ReviewOperationError('delivery_unroutable', reason === 'origin_missing' ? 'message target was not found' : 'message target has no natural delivery cycle', { node_id: nodeId, reason });
 }
@@ -33,7 +34,11 @@ export async function deliverNodeMessage(args) {
         deliveryUnroutable(args.node_id, 'origin_missing');
     if (args.mode === 'interactive' && isBrokerLive(target)) {
         try {
-            await deliverLive(args.node_id, args.body);
+            // Inbox delivery supplies the raw body as an entry in its outer inbox
+            // card; only live delivery needs this message's own envelope.
+            await deliverLive(args.node_id, args.runtime === undefined
+                ? args.body
+                : formatCard(args.runtime.kind, args.runtime.facts, args.body));
             // The broker acknowledgement is asynchronous to the SQLite guard. Recheck
             // before reporting an engine receipt so a final that committed during the
             // request is not represented as a routable delivery.

package/dist/daemon/review/comment-notify.js

@@ -70,6 +70,14 @@ export async function notifyComment(args) {
                 comment_id: args.comment.comment_id,
                 verb: args.verb,
             },
+            runtime: {
+                kind: 'review-comment',
+                facts: {
+                    review_id: args.review.review_id,
+                    comment_id: args.comment.comment_id,
+                    verb: args.verb,
+                },
+            },
         });
     }
     catch (error) {

package/dist/daemon/review/deliver.js

@@ -1,5 +1,5 @@
 import { FinalizationError, pushFinal, redeliverFinalReport } from '../../core/feed/feed.js';
-import { formatReviewApproval } from '../../shared/generated-context.js';
+import { formatCard } from '../../shared/generated-context.js';
 import { deliverNodeMessage } from '../messaging/node-message.js';
 function approvalBody(review, resultPath) {
     const summary = review.changed
@@ -9,7 +9,7 @@ function approvalBody(review, resultPath) {
 }
 /** Render the immutable approval fact without replaying comment text. */
 export function renderApprovalMessage(review, resultPath) {
-    return formatReviewApproval(approvalBody(review, resultPath));
+    return formatCard('review-approval', { review: review.review_id, file: review.file }, approvalBody(review, resultPath));
 }
 function recordedFailedFanout(review, reportBasename) {
     const error = review.delivery_error;

package/dist/daemon/review/finish.js

@@ -89,7 +89,7 @@ async function finishApproved(review, result) {
         }
     }
     current = requireVisibleReview(review.review_id);
-    retireCompanion(current.companion_node_id, 'approved');
+    await retireCompanion(current.companion_node_id, 'approved');
     return requireVisibleReview(review.review_id);
 }
 async function finishCanceled(review, winningWrite, args) {
@@ -150,7 +150,7 @@ async function finishCanceled(review, winningWrite, args) {
     current = requireVisibleReview(review.review_id);
     if (canceledTicket === undefined)
         canceledTicket = ticketResult(current);
-    retireCompanion(current.companion_node_id, 'canceled');
+    await retireCompanion(current.companion_node_id, 'canceled');
     return { record: requireVisibleReview(review.review_id), ...(canceledTicket === undefined ? {} : { ticket_result: canceledTicket }) };
 }
 /** Tell the origin its review was submitted but is finishing behind the
@@ -164,6 +164,7 @@ async function noteSubmitQueued(review) {
             mode: 'quiet',
             label: 'human review submitted — result to follow',
             data: { review_id: review.review_id },
+            runtime: { kind: 'review-queued', facts: { review_id: review.review_id } },
             body: `The human submitted their review of \`${review.file}\`; the document is still being edited. `
                 + "You'll be notified with the result once the review completes. Nothing is needed from you now.",
         });

package/dist/pi-extensions/__tests__/canvas-goal-capture-envelope.test.d.ts

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