@north-light/crouter 0.3.204 → 0.3.206

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

@@ -9,7 +9,8 @@ import { cancelPendingHumanMessages } from '../../../core/feed/inbox.js';
 import { withFreshTerminalGuard } from '../../../core/canvas/canvas.js';
 import { assertNotFinalized, assertFinalizedForReopen, commitReopen } from '../../../core/runtime/reopen.js';
 import { writeOutputSchema } from '../../../core/runtime/structured-output.js';
-import { appendSituationalContext } from '../../../core/runtime/situational-context.js';
+import { appendSituationalContext, formatSituationalProse } from '../../../core/runtime/situational-context.js';
+import { formatDataCard } from '../../../shared/generated-context.js';
 import { hasNoNaturalCycle } from '../../../core/runtime/revive-all.js';
 import { readGoal } from '../../../core/runtime/kickoff.js';
 import { readRoadmap } from '../../../core/runtime/roadmap.js';
@@ -20,6 +21,53 @@ import { ApiError } from '../../../api/index.js';
 // POST /v1/nodes/{id}/messages
 // ---------------------------------------------------------------------------
 const TIERS = ['critical', 'urgent', 'normal', 'deferred'];
+/** Validate + narrow one caller-supplied runtime card. A bare kind is crouter's
+ *  own closed vocabulary, so a caller must namespace: no product can shadow a
+ *  core kind, and the parser's decode rule keys on exactly this property. */
+function parseCardRequest(value, field) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw usage(`${field} must be an object { kind, facts?, body? }`);
+    }
+    const raw = value;
+    const kind = raw['kind'];
+    if (typeof kind !== 'string' || kind.trim() === '')
+        throw usage(`${field}.kind is required`);
+    if (!kind.includes(':'))
+        throw usage(`${field}.kind must be namespaced (contain ':'): ${kind}`);
+    const card = { kind };
+    const facts = raw['facts'];
+    if (facts !== undefined) {
+        if (typeof facts !== 'object' || facts === null || Array.isArray(facts)) {
+            throw usage(`${field}.facts must be an object of string or number values`);
+        }
+        const values = {};
+        for (const [name, fact] of Object.entries(facts)) {
+            if (typeof fact !== 'string' && typeof fact !== 'number') {
+                throw usage(`${field}.facts.${name} must be a string or number`);
+            }
+            values[name] = fact;
+        }
+        card.facts = values;
+    }
+    const body = raw['body'];
+    if (body !== undefined) {
+        if (typeof body !== 'string')
+            throw usage(`${field}.body must be a string`);
+        card.body = body;
+    }
+    return card;
+}
+/** Render a validated card. `formatDataCard` escapes the body exactly once —
+ *  this is the ONLY escape on the path — and rejects a fact name that cannot be
+ *  an XML attribute, which is caller input and so a 400, not a 500. */
+function renderCard(card, field) {
+    try {
+        return formatDataCard(card.kind, card.facts ?? {}, card.body ?? '');
+    }
+    catch (err) {
+        throw usage(`${field}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /** Validate + narrow the send-message body (spec §6.2). */
 function parseSendBody(body) {
     if (typeof body !== 'object' || body === null) {
@@ -34,10 +82,29 @@ function parseSendBody(body) {
     const hasBody = typeof text === 'string' && text.trim() !== '';
     const hasSituational = typeof situational === 'string' && situational.trim() !== '';
     const hasSchema = typeof outputSchema === 'string' && outputSchema.trim() !== '';
-    // A body is required unless this is a fresh revive, a situational-only update,
+    const situationalCardRaw = b['situational_card'];
+    const contextCardsRaw = b['context_cards'];
+    const situationalCard = situationalCardRaw === undefined
+        ? undefined
+        : parseCardRequest(situationalCardRaw, 'situational_card');
+    if (contextCardsRaw !== undefined && !Array.isArray(contextCardsRaw)) {
+        throw usage('context_cards must be an array of { kind, facts?, body? }');
+    }
+    const contextCards = contextCardsRaw?.map((card, index) => parseCardRequest(card, `context_cards[${index}]`));
+    // The sidecar is singular, so the card form and the prose form are one slot.
+    if (situationalCard !== undefined && typeof situational === 'string' && situational !== '') {
+        throw usage('situational_card and situational_context are mutually exclusive');
+    }
+    const hasCards = situationalCard !== undefined || (contextCards !== undefined && contextCards.length > 0);
+    // A body is required unless this is a fresh revive, a context-only update,
     // or a one-off output-schema request.
-    if (!fresh && !hasBody && !hasSituational && !hasSchema) {
-        throw usage('a message requires a non-empty body (or fresh: true, situational_context, or output_schema)');
+    if (!fresh && !hasBody && !hasSituational && !hasSchema && !hasCards) {
+        throw usage('a message requires a non-empty body (or fresh: true, situational_context, a runtime card, or output_schema)');
+    }
+    // A fresh revive appends no inbox entry, so a one-shot card would have no
+    // carrier. The sidecar card survives the revive through the bearings.
+    if (fresh && contextCards !== undefined && contextCards.length > 0) {
+        throw usage('context_cards cannot ride a fresh revive (no inbox entry carries them)');
     }
     if (tierRaw !== undefined && !TIERS.includes(tierRaw)) {
         throw usage(`invalid tier: ${String(tierRaw)} (expected critical|urgent|normal|deferred)`);
@@ -51,6 +118,10 @@ function parseSendBody(body) {
         out.reopen = true;
     if (typeof situational === 'string')
         out.situational_context = situational;
+    if (situationalCard !== undefined)
+        out.situational_card = situationalCard;
+    if (contextCards !== undefined)
+        out.context_cards = contextCards;
     if (typeof outputSchema === 'string')
         out.output_schema = outputSchema;
     if (typeof b['from'] === 'string')
@@ -62,8 +133,11 @@ function parseSendBody(body) {
     if (delivery === 'interactive') {
         // Interactive delivery is a live-conversation send: a plain immediate body,
         // nothing that only makes sense on the durable path.
+        // Runtime cards ARE accepted here: 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 (D11).
         if (fresh || out.reopen === true || out.situational_context !== undefined || out.output_schema !== undefined) {
-            throw usage('interactive delivery supports a plain body only (no fresh, reopen, situational_context, or output_schema)');
+            throw usage('interactive delivery supports a body and runtime cards only (no fresh, reopen, situational_context, or output_schema)');
         }
         if (!hasBody)
             throw usage('interactive delivery requires a non-empty body');
@@ -122,9 +196,14 @@ async function handleMessage(ctx) {
     const tier = (req.tier ?? 'normal');
     const from = req.from ?? null;
     const hasBody = req.body.trim() !== '';
-    const situational = req.situational_context !== undefined && req.situational_context.trim() !== ''
-        ? req.situational_context.trim()
-        : null;
+    // One sidecar slot: the caller's rendered card, or prose rendered as one.
+    const sidecar = req.situational_card !== undefined
+        ? renderCard(req.situational_card, 'situational_card')
+        : req.situational_context !== undefined
+            ? formatSituationalProse(req.situational_context.trim())
+            : '';
+    const hasSidecar = sidecar !== '';
+    const oneShotCards = (req.context_cards ?? []).map((card, index) => renderCard(card, `context_cards[${index}]`));
     const schema = req.output_schema !== undefined && req.output_schema.trim() !== ''
         ? parseSchema(req.output_schema)
         : null;
@@ -138,8 +217,8 @@ async function handleMessage(ctx) {
         if (!req.reopen)
             assertNotFinalized(id);
         assertRecoverableForFresh(id);
-        if (situational !== null)
-            appendSituationalContext(id, situational);
+        if (hasSidecar)
+            appendSituationalContext(id, sidecar);
         if (req.reopen)
             commitReopen(id, expectedFinalReport);
         const result = reviveNode(id, { resume: false });
@@ -158,7 +237,9 @@ async function handleMessage(ctx) {
     //     straight there (append + revive, watcher delivers post-boot). ---
     if (req.delivery === 'interactive' && isBrokerLive(meta)) {
         try {
-            await deliverLive(id, req.body);
+            if (hasSidecar)
+                appendSituationalContext(id, sidecar);
+            await deliverLive(id, req.body, [...(hasSidecar ? [sidecar] : []), ...oneShotCards]);
             const body = {
                 node_id: id,
                 delivered: true,
@@ -182,10 +263,11 @@ async function handleMessage(ctx) {
             assertNotFinalized(id);
         if (schema !== null)
             writeOutputSchema(id, 'oneoff', schema);
-        if (situational !== null)
-            appendSituationalContext(id, situational);
+        if (hasSidecar)
+            appendSituationalContext(id, sidecar);
         if (req.reopen)
             commitReopen(id, expectedFinalReport);
+        const cards = oneShotCards.length > 0 ? { cards: oneShotCards } : {};
         if (hasBody || schema !== null) {
             const messageBody = hasBody
                 ? req.body
@@ -195,16 +277,18 @@ async function handleMessage(ctx) {
                 tier,
                 kind: 'message',
                 label: label(messageBody),
-                data: { body: messageBody, ...(situational !== null ? { situational: true } : {}) },
+                data: { body: messageBody, ...(hasSidecar ? { situational: true } : {}), ...cards },
             });
         }
-        // Situational-only: a hidden wake marker excluded from the visible digest.
+        // Context-only: a hidden wake marker excluded from the visible digest. Its
+        // one-shot cards have no visible delivery to ride, so the watcher's context
+        // channel carries them.
         return appendInbox(id, {
             from,
             tier,
             kind: 'message',
-            label: '(ambient context updated)',
-            data: { situational: true, situationalOnly: true },
+            label: hasSidecar ? '(ambient context updated)' : '(context delivered)',
+            data: { ...(hasSidecar ? { situational: true } : {}), situationalOnly: true, ...cards },
         });
     };
     // Deferred guard: a done/canceled/finalized target has no natural

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

@@ -9,6 +9,7 @@
 import { readdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { appendSituationalContext, closeNode, getNode, listNodes, nowIso, reviveNode, } from '../../../index.js';
+import { formatSituationalProse } from '../../../core/runtime/situational-context.js';
 import { assertLaunchModelRegistered, forkNode, resolveProfileId, spawnChild } from '../../../core/runtime/spawn.js';
 import { childrenOf, subscribersOf, subscriptionsOf, setMessageWait, updateNode } from '../../../core/canvas/canvas.js';
 import { subtreeIds } from '../../../core/canvas/nav-model.js';
@@ -98,14 +99,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 +115,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 +331,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(),
     };
@@ -540,7 +544,7 @@ export async function handleConfig(ctx, deps = {}) {
     let meta = requireMeta(id);
     const patch = ctx.body ?? {};
     if (patch.situational_context !== undefined) {
-        appendSituationalContext(id, patch.situational_context);
+        appendSituationalContext(id, formatSituationalProse(patch.situational_context));
     }
     if (patch.model !== undefined) {
         const pinned = isProviderPinnedModelToken(patch.model);

package/dist/daemon/human/finish.js

@@ -9,7 +9,7 @@ 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';
@@ -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
@@ -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/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

@@ -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 {};

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

@@ -0,0 +1,96 @@
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/pi-extensions/__tests__/canvas-goal-capture-envelope.test.ts
+//
+// The revive-kickoff exclusion in canvas-goal-capture. A fresh revive's kickoff
+// arrives as a LAUNCH PROMPT — an ordinary interactive input event, not an
+// extension injection — so without an exclusion it looks exactly like a bare
+// root's first typed message: it would be written to context/initial-prompt.md
+// as the node's mandate and would name the node from the runtime's own words.
+//
+// The exclusion used to key on the kickoff's opening sentence. It now keys on
+// the <runtime kind="revive" …> envelope, and this file pins that the real
+// builder's real bytes are still excluded — the two changes are one unit
+// precisely because the envelope moves the bytes the old check read.
+//
+// The naming attempt is observed at the daemon socket: generateAndCommitInitialName
+// starts by asking crtrd for the node's projection, so a request for a node id is
+// proof that naming ran for it, and no request is proof that it did not.
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import registerCanvasGoalCapture from '../canvas-goal-capture.js';
+import { createNode } from '../../core/canvas/canvas.js';
+import { closeDb } from '../../core/canvas/db.js';
+import { apiSocketPath } from '../../core/canvas/paths.js';
+import { buildReviveKickoff, drainBearings } from '../../core/runtime/kickoff.js';
+let home;
+let socket;
+/** Every request line the extension's naming path sent to the daemon socket. */
+const requests = [];
+function node(id) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
+/** Register the extension and hand back its input handler. */
+function handler() {
+    let captured;
+    registerCanvasGoalCapture({ on: (_event, fn) => { captured = fn; } });
+    assert.ok(captured !== undefined, 'the extension registers an input handler');
+    return captured;
+}
+function initialPromptPath(id) {
+    return join(home, 'nodes', id, 'context', 'initial-prompt.md');
+}
+async function waitForRequestMentioning(id) {
+    for (let i = 0; i < 200; i++) {
+        if (requests.some((line) => line.includes(id)))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error(`no daemon request mentioning ${id} arrived`);
+}
+before(async () => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-goal-capture-'));
+    process.env['CRTR_HOME'] = home;
+    // A stub daemon: it records the request and hangs up, so the naming path fails
+    // fast (and silently, as it must) without any model call.
+    socket = createServer((connection) => {
+        connection.on('data', (chunk) => {
+            requests.push(chunk.toString('utf8'));
+            connection.destroy();
+        });
+    });
+    await new Promise((resolve) => socket.listen(apiSocketPath(), resolve));
+});
+after(async () => {
+    closeDb();
+    await new Promise((resolve) => socket.close(() => resolve()));
+    rmSync(home, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+    delete process.env['CRTR_NODE_ID'];
+});
+test('a fresh-revive kickoff seeds no mandate and no name; a human first message seeds both', async () => {
+    const revived = createNode(node('revived-node'));
+    const kickoff = buildReviveKickoff(revived, drainBearings(revived));
+    process.env['CRTR_NODE_ID'] = revived.node_id;
+    handler()({ type: 'input', text: kickoff, source: 'interactive' });
+    const bare = createNode(node('bare-root'));
+    process.env['CRTR_NODE_ID'] = bare.node_id;
+    handler()({ type: 'input', text: 'build me a receipt tracker', source: 'interactive' });
+    // The human message's naming call is the clock: both inputs ran through the
+    // same handler, so once its request has landed the revive's would have too.
+    await waitForRequestMentioning(bare.node_id);
+    assert.equal(existsSync(initialPromptPath(revived.node_id)), false, 'a fresh revive never overwrites the node mandate with the runtime kickoff');
+    assert.equal(requests.some((line) => line.includes(revived.node_id)), false, 'a fresh revive never names the node from the runtime kickoff');
+    assert.equal(readFileSync(initialPromptPath(bare.node_id), 'utf8').trim(), 'build me a receipt tracker', "a bare root's first typed message is still captured as its mandate");
+});

package/dist/pi-extensions/__tests__/canvas-stophook-agentend.test.js

@@ -409,7 +409,7 @@ test('stalled leaf (nothing live to await, no final) is still reprompted', async
     let shutdown = false;
     await settle(pi, stopEvent('I think I am basically done here'), { shutdown: () => { shutdown = true; } });
     assert.equal(pi.injected.length, 1, 'the stall reprompt fired');
-    assert.equal(pi.injected[0].content, STALL_REPROMPT, 'reprompt carries the stall nudge to push final / ask');
+    assert.equal(pi.injected[0].content, `<runtime kind="stop-guard" reason="stalled">${STALL_REPROMPT}</runtime>`, 'reprompt carries the stall nudge to push final / ask');
     assert.equal(pi.injected[0].deliverAs, 'followUp', 'reprompt delivered as a followUp');
     assert.equal(shutdown, false, 'a stalled leaf is NOT shut down — it is re-prompted to finish');
     assert.notEqual(getNode('leaf')?.intent, 'idle-release', 'a stalled leaf does not idle-release');

package/dist/pi-extensions/__tests__/canvas-stophook-context-nudge.test.js

@@ -98,7 +98,7 @@ test('band crossing mid-run (tool calls present) → context nudge is a STEER',
     await pi.fire('turn_end', turnEnd([{ type: 'toolCall', id: 't1', name: 'bash', arguments: {} }], 'toolUse'), ctxAt(150_000));
     assert.equal(pi.steered.length, 1, 'exactly one steer delivered');
     assert.equal(pi.steered[0].deliverAs, 'steer');
-    assert.match(pi.steered[0].content, /^\[crtr\] Context ~150k/);
+    assert.match(pi.steered[0].content, /^<runtime kind="context-nudge">Context ~150k/);
     assert.equal(pi.held.length, 0, 'nothing held for nextTurn');
 });
 test('band crossing on the FINAL message (no tool calls) → nudge is HELD as nextTurn, never a steer', async () => {
@@ -111,7 +111,7 @@ test('band crossing on the FINAL message (no tool calls) → nudge is HELD as ne
     assert.equal(pi.held.length, 1, 'nudge held for the next user message');
     assert.equal(pi.held[0].deliverAs, 'nextTurn');
     assert.equal(pi.held[0].customType, 'crtr-context-nudge');
-    assert.match(pi.held[0].content, /^\[crtr\] Context ~150k/);
+    assert.match(pi.held[0].content, /^<runtime kind="context-nudge">Context ~150k/);
     assert.notEqual(pi.held[0].triggerTurn, true, 'must not trigger a turn');
 });
 test('a truncated tool-calling turn (stopReason length) still steers — the loop continues past failed calls', async () => {

package/dist/pi-extensions/broker-local.d.ts

@@ -1,5 +1,3 @@
-import { REVIVE_KICKOFF_SENTINEL } from '../shared/generated-context.js';
-export { REVIVE_KICKOFF_SENTINEL };
 /** Persist a bare root's first real interactive message without clobbering an
  * existing spawning mandate. This is broker-local file state, not canvas.db. */
 export declare function captureGoalIfAbsent(nodeId: string, text: string): boolean;

package/dist/pi-extensions/broker-local.js

@@ -7,11 +7,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { CRTR_DIR_NAME } from '../types.js';
-import { REVIVE_KICKOFF_SENTINEL } from '../shared/generated-context.js';
 import { brokerExtensionState, commitBrokerGeneratedName, } from '../core/runtime/broker/daemon-ops.js';
 import { publishNodeNamed } from '../core/runtime/broker/node-named.js';
 import { headlessName, headlessNameFromConversation, sanitizeSessionName, slugFromPrompt, } from '../core/runtime/naming.js';
-export { REVIVE_KICKOFF_SENTINEL };
 function contextDir(nodeId) {
     if (nodeId === '' || nodeId === '.' || nodeId === '..' || /[\\/\0]/u.test(nodeId)) {
         throw new TypeError('node_id must be a non-empty path segment');

package/dist/pi-extensions/canvas-context-intro.js

@@ -26,10 +26,10 @@
 //
 // Plain TS-with-types — no imports from @earendil-works/* so this compiles inside
 // crouter's own tsc build without a dep on the pi packages.
-import { CONTEXT_INTRO_CUSTOM_TYPE } from '../shared/generated-context.js';
+import { CONTEXT_INTRO_CUSTOM_TYPE, formatCard, parseCard } from '../shared/generated-context.js';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { buildContextBearingsFromState, buildForkBearingsFromState, buildProjectContextBlockForBroker } from '../core/runtime/broker-extension-render.js';
-import { situationalContextBlock } from '../core/runtime/situational-context.js';
+import { situationalContextEnvelope } from '../core/runtime/situational-context.js';
 import { saveInjectedDocs, sharedInjectedDocs } from '../core/substrate/injected-store.js';
 import { truncateToWidth } from './truncate.js';
 /** The `customType` stamped on the injected session message. Used both to write
@@ -44,13 +44,13 @@ export { CONTEXT_INTRO_CUSTOM_TYPE };
  *  crouter context. Exported for testing. */
 export async function buildContextIntro(nodeId, seen) {
     const state = await brokerExtensionState(nodeId);
-    return buildContextBearingsFromState(state, buildProjectContextBlockForBroker(state.node.cwd), situationalContextBlock(nodeId), seen);
+    return buildContextBearingsFromState(state, buildProjectContextBlockForBroker(state.node.cwd), situationalContextEnvelope(nodeId) ?? '', seen);
 }
 /** Build the compact node-scoped update for a fork whose copied branch already
  *  carries a full crouter baseline. Exported for testing. */
 export async function buildForkContextIntro(nodeId) {
     const state = await brokerExtensionState(nodeId);
-    return buildForkBearingsFromState(state, situationalContextBlock(nodeId));
+    return buildForkBearingsFromState(state, situationalContextEnvelope(nodeId) ?? '');
 }
 // ---------------------------------------------------------------------------
 // Collapsed-by-default rendering
@@ -112,7 +112,8 @@ export function renderContextMessage(message, options, theme) {
                 return [paint('dim', truncateToWidth(stub, w))];
             }
             const lines = [paint('customMessageLabel', truncateToWidth(`[${CONTEXT_INTRO_CUSTOM_TYPE}]`, w)), ''];
-            for (const raw of messageText(message).split('\n')) {
+            const body = parseCard({ role: 'custom', customType: message.customType, content: messageText(message) })?.body ?? messageText(message);
+            for (const raw of body.split('\n')) {
                 for (const wrapped of wrapLine(raw, w))
                     lines.push(paint('customMessageText', wrapped));
             }
@@ -168,11 +169,11 @@ export function registerCanvasContextIntro(pi) {
         // docs and needs no set.
         const seen = inherited && forked ? undefined : sharedInjectedDocs(nodeId);
         const content = inherited && forked
-            ? buildForkBearingsFromState(state, situationalContextBlock(nodeId))
-            : buildContextBearingsFromState(state, buildProjectContextBlockForBroker(state.node.cwd), situationalContextBlock(nodeId), seen);
+            ? buildForkBearingsFromState(state, situationalContextEnvelope(nodeId) ?? '')
+            : buildContextBearingsFromState(state, buildProjectContextBlockForBroker(state.node.cwd), situationalContextEnvelope(nodeId) ?? '', seen);
         pi.sendMessage({
             customType: CONTEXT_INTRO_CUSTOM_TYPE,
-            content,
+            content: formatCard('bearings', {}, content),
             display: true,
             details: { nodeId },
         });