@north-light/crouter 0.3.203 → 0.3.205

package/dist/clients/conversation/projection.js

@@ -1,7 +1,6 @@
 // projection.ts — the surface-neutral reducer that turns a broker snapshot and
 // its live frames into one ordered transcript model. Renderers retain their own
 // folding and presentation; this module owns only wire-state reconciliation.
-import { isInboxDigest } from '../../shared/generated-context.js';
 import { normalizeToolGroupSummary, normalizeToolGroupSummaryRecord } from '../../shared/tool-groups.js';
 import { DEFAULT_WORKING_ACTIVITY } from '../../shared/working-activity.js';
 export function initialConvState() {
@@ -32,34 +31,6 @@ export function restoreConvState(entry) {
         toolGroupSummaryDetails: normalizeToolGroupSummaryRecord(entry.toolGroupSummaries),
     };
 }
-/** Plain text of a user message (string content or concatenated text blocks),
- *  for inbox-digest detection. */
-function userMessageText(m) {
-    const content = m.content;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => !!b && b.type === 'text')
-            .map((b) => (typeof b.text === 'string' ? b.text : ''))
-            .join('');
-    }
-    return '';
-}
-/** Tag a `role:'user'` message as inbox-origin when its text matches the
- *  canvas-inbox-watcher coalesce digest; other messages pass through unchanged.
- *  The broker relays pi AgentMessages verbatim and never carries `origin` on the
- *  wire, so this is the sole writer of `origin:'inbox'` — recognized from the
- *  digest text. (Idempotent: a message already tagged is left as-is.) */
-function tagInboxOrigin(m) {
-    if (roleOf(m) !== 'user')
-        return m;
-    if (m.origin)
-        return m;
-    if (!isInboxDigest(userMessageText(m)))
-        return m;
-    return { ...m, origin: 'inbox' };
-}
 /** An empty assistant message shaped so the next `message_update`/`message_end`
  *  (which replace, not append — see `reduce`'s `message_update` case) has a
  *  slot to land on. */
@@ -85,7 +56,7 @@ function placeholderAssistant() {
  *  first `message_update` REPLACES that message wholesale, so no duplicate or
  *  dropped turn results. */
 export function applySnapshot(snapshot, previous) {
-    const messages = snapshot.messages.map(tagInboxOrigin);
+    const messages = snapshot.messages;
     const toolGroupSummaryDetails = snapshotToolGroupSummaries(snapshot);
     const toolGroupSummaries = summaryTexts(toolGroupSummaryDetails);
     const isStreaming = snapshot.state?.isStreaming === true;
@@ -263,14 +234,13 @@ export function reduce(state, event) {
                 executingToolIds: state.executingToolIds.size ? new Set() : state.executingToolIds,
             };
         case 'message_start': {
-            // User messages arrive complete on message_start (no streaming deltas), so
-            // tagging here is sufficient — update/end only mutate the assistant message.
-            const tagged = tagInboxOrigin(event.message);
-            const messages = [...state.messages, tagged];
-            const isAssistant = roleOf(tagged) === 'assistant';
+            // User messages arrive complete on message_start (no streaming deltas).
+            const message = event.message;
+            const messages = [...state.messages, message];
+            const isAssistant = roleOf(message) === 'assistant';
             let partialToolResults = state.partialToolResults;
-            if (roleOf(tagged) === 'toolResult') {
-                const id = tagged.toolCallId;
+            if (roleOf(message) === 'toolResult') {
+                const id = message.toolCallId;
                 if (typeof id === 'string' && partialToolResults.has(id)) {
                     const next = new Map(partialToolResults);
                     next.delete(id);

package/dist/commands/node/create.js

@@ -71,7 +71,7 @@ function nodeNewParams() {
         { kind: 'stdin', name: 'prompt', required: false, constraint: 'First user message. Required unless --no-kickoff is given.' },
         { kind: 'flag', name: 'kind', type: 'string', required: false, default: 'general', constraint: 'Persona kind. The <kinds> list below names every top-level installable kind.' },
         { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, default: 'base', constraint: 'Persona mode. base for hands-on work; orchestrator when the unit itself needs decomposition across children.' },
-        { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Pin the node to this directory. Defaults to the spawner\u2019s directory for a managed child, and to the profile home for a root (`crtr profile show <profile>`).' },
+        { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Pin the node to this directory. Defaults to the spawner\u2019s directory for a managed child, and to the directory this command runs in for a root.' },
         { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Display name. Defaults to the kind.' },
         { kind: 'flag', name: 'parent', type: 'string', required: false, constraint: 'Parent node id. Defaults to the calling node.' },
         { kind: 'flag', name: 'node-id', type: 'string', required: false, constraint: 'Exact id for the new node; lowercase letters, digits, and hyphens only, at most 128 characters. Rejected if already present.' },

package/dist/commands/profile/project.js

@@ -31,7 +31,7 @@ const addLeaf = defineLeaf({
                 name: 'home',
                 type: 'bool',
                 required: false,
-                constraint: "Also make this directory the profile's home — where every node under it is pinned unless the create passes an explicit --cwd. Defaults to the first project dir; pass this on an already-listed dir to re-point it.",
+                constraint: "Also make this directory the profile's home — where a node under it runs when its create names no directory. Defaults to the first project dir; pass this on an already-listed dir to re-point it.",
             },
         ],
         output: [

package/dist/commands/profile/show.js

@@ -22,7 +22,7 @@ export const showLeaf = defineLeaf({
             { name: 'profile_id', type: 'string', required: true, constraint: 'Stable directory id.' },
             { name: 'name', type: 'string', required: true, constraint: 'Manifest name.' },
             { name: 'projects', type: 'string[]', required: true, constraint: 'Absolute project directories, in manifest order.' },
-            { name: 'home', type: 'string | null', required: true, constraint: 'The directory every node under this profile is pinned to unless its create passes an explicit --cwd. Defaults to the first project; re-point it with `profile project add --home`. Null when the profile owns no projects (the root profile), in which case nodes fall back to the creating directory.' },
+            { name: 'home', type: 'string | null', required: true, constraint: 'Where a node under this profile runs when its create names no directory at all — an explicit --cwd and the directory a root is launched from both win over it. Defaults to the first project; re-point it with `profile project add --home`. Null when the profile owns no projects (the root profile).' },
             { name: 'created_at', type: 'string', required: true, constraint: 'ISO 8601 creation timestamp.' },
             { name: 'last_used_at', type: 'string | null', required: true, constraint: 'ISO 8601 timestamp of the most recent selection, or null if never selected.' },
             { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the profile directory.' },

package/dist/commands/profile.js

@@ -30,7 +30,7 @@ export function registerProfile() {
         help: {
             name: 'profile',
             summary: 'create, inspect, and manage profiles \u2014 agent identities with their own project purview and memory store',
-            model: 'A profile owns a `home` — the first of its project dirs unless `project add --home` re-points it — and every node created under the profile is pinned there, so cwd selects the profile and the profile then supplies where its nodes run. Only `node new --cwd` (or inheriting a spawner already elsewhere, notably inside a managed worktree) overrides that; the root profile has no home, so nodes under it stay in the directory that created them. `new` creates one from a name (+ at most one initial `--project`, which becomes its home). `list` inventories every profile as JSONL. `show` prints one manifest in full. `rename` changes only the manifest name \u2014 the profile_id is stable across a rename. `delete --force` removes the profile after cascading through its nodes, matching schedules, originating inbox/review state, and default pins; `--detach --force` instead preserves nodes and human history while clearing the profile identity and globalizing its schedules. Both modes block while a matching node owns an open managed worktree and never touch the project directories the profile pointed at. `project` widens/narrows a profile\u2019s project purview (the dirs it resolves memory + config from). `default` pins which profile a directory defaults to at startup so the chooser stops asking \u2014 directory-scoped, independent of purview. `env` manages a profile-scoped 0600 store of env vars injected directly into every broker launched under that profile \u2014 set on stdin, list names only (never values), or remove one; no `spawnEnv.allow` entry needed. Every manifest verb but `new`/`list` takes <profile> as an exact id or a unique manifest name; an ambiguous name fails listing every matching id.',
+            model: 'A profile owns a `home` — the first of its project dirs unless `project add --home` re-points it — which is where a node under the profile runs when its create names no directory at all. A node lands in the directory it was launched from when there is one: `node new --cwd`, an inherited spawner directory (notably inside a managed worktree), or the directory a root was started in. So one profile can cover many working directories — cwd selects the identity, and the launch decides where the work happens. `new` creates one from a name (+ at most one initial `--project`, which becomes its home). `list` inventories every profile as JSONL. `show` prints one manifest in full. `rename` changes only the manifest name \u2014 the profile_id is stable across a rename. `delete --force` removes the profile after cascading through its nodes, matching schedules, originating inbox/review state, and default pins; `--detach --force` instead preserves nodes and human history while clearing the profile identity and globalizing its schedules. Both modes block while a matching node owns an open managed worktree and never touch the project directories the profile pointed at. `project` widens/narrows a profile\u2019s project purview (the dirs it resolves memory + config from). `default` pins which profile a directory defaults to at startup so the chooser stops asking \u2014 directory-scoped, independent of purview. `env` manages a profile-scoped 0600 store of env vars injected directly into every broker launched under that profile \u2014 set on stdin, list names only (never values), or remove one; no `spawnEnv.allow` entry needed. Every manifest verb but `new`/`list` takes <profile> as an exact id or a unique manifest name; an ambiguous name fails listing every matching id.',
         },
         children: [newLeaf, listLeaf, showLeaf, renameLeaf, deleteLeaf, projectBranch, defaultBranch, envBranch],
     });

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -17,6 +17,7 @@ import { reportsDir } from '../canvas/paths.js';
 import { closeDb } from '../canvas/db.js';
 import { appendInbox, coalesce, finalizeInboxEntry } from '../feed/inbox.js';
 import { appendSituationalContext, SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../runtime/situational-context.js';
+import { parseCard } from '../../shared/generated-context.js';
 // Drive the watcher's injectable cadence seam (CRTR_WATCHER_TICK_MS /
 // CRTR_WATCHER_DEBOUNCE_MS) at a fast tempo so the watcher delivers in tens of
 // milliseconds, not seconds — exactly the resolve+seed tick, read tick, and
@@ -49,6 +50,11 @@ function makeFakePi() {
     };
 }
 const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+/** The text of a batch that must coalesce into exactly one delivery. */
+function onlyDelivery(deliveries) {
+    assert.equal(deliveries.length, 1, 'expected a single delivery');
+    return deliveries[0].text;
+}
 // Register the watcher, then fire session_start — the real lifecycle gate
 // that arms its poll interval and initial tick (see canvas-inbox-watcher.ts).
 // registerCanvasInboxWatcher() alone only wires up handlers; without this the
@@ -75,7 +81,7 @@ async function waitFor(predicate, timeoutMs = 3000, stepMs = 10) {
         await wait(stepMs);
     }
 }
-test('coalesce inlines short report bodies with a trailing artifact pointer and only hints for remaining canonical refs', () => {
+test('coalesce renders one inbox card whose entries inline short report bodies and carry their refs', () => {
     freshNode('child');
     const child = createNode({
         node_id: 'child',
@@ -90,38 +96,83 @@ test('coalesce inlines short report bodies with a trailing artifact pointer and
     const reportPath = join(reportsDir(child.node_id), 'short-update.md');
     mkdirSync(reportsDir(child.node_id), { recursive: true });
     writeFileSync(reportPath, '---\nnode: child\nkind: update\n---\nshort report body', 'utf8');
-    const digest = coalesce([
+    const digest = onlyDelivery(coalesce([
         finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'update', label: 'short report', ref: 'child:reports/short-update.md' }),
+    ]));
+    // The envelope is the whole message: a reader that finds it anywhere else
+    // attributes the digest to the person.
+    assert.equal(digest.startsWith('<runtime kind="inbox"'), true);
+    assert.equal(digest.endsWith('</runtime>'), true);
+    const card = parseCard({ role: 'user', content: digest });
+    assert.notEqual(card, null);
+    assert.equal(card.kind, 'inbox');
+    assert.deepEqual({ ...card.facts }, { senders: '1', updates: '1' });
+    assert.equal(card.senders.length, 1);
+    assert.equal(card.senders[0].id, 'child');
+    // The label is NOT reprinted above the body it duplicates.
+    assert.deepEqual(card.senders[0].entries, [
+        { kind: 'update', disposition: 'report', body: 'short report body', ref: 'child:reports/short-update.md' },
     ]);
-    // The label is NOT reprinted above the body it duplicates; the path trails it.
-    assert.doesNotMatch(digest, /\[update\] short report/);
-    assert.match(digest, /\[update\]\n {4}short report body\n/);
-    assert.match(digest, new RegExp(`\\(report: ${reportPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\)`));
-    assert.doesNotMatch(digest, /Dereference a ref with/);
-    const guidance = 'Dereference a ref with `crtr canvas history read <ref>`.';
-    const canonical = coalesce([
-        finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'final', label: 'done', ref: 'child:reports/final.md' }),
+    assert.equal(reportPath.endsWith('short-update.md'), true);
+    // A report too large to inline (here: absent) keeps its label and its ref.
+    const canonical = parseCard({
+        role: 'user',
+        content: onlyDelivery(coalesce([
+            finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'final', label: 'done', ref: 'child:reports/final.md' }),
+        ])),
+    });
+    assert.deepEqual(canonical.senders[0].entries, [
+        { kind: 'final', disposition: 'report', body: 'done', ref: 'child:reports/final.md' },
     ]);
-    assert.equal(canonical.endsWith(`\n\n${guidance}`), true);
-    const spilled = coalesce([
-        finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'message', label: 'long', ref: '/tmp/message.md', data: { body: 'long body' } }),
+    assert.equal(canonical.senders[0].finished, true);
+    const spilled = parseCard({
+        role: 'user',
+        content: onlyDelivery(coalesce([
+            finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'message', label: 'long', ref: '/tmp/message.md', data: { body: 'long body' } }),
+        ])),
+    });
+    assert.deepEqual(spilled.senders[0].entries, [
+        { kind: 'message', disposition: 'report', body: 'long body', ref: '/tmp/message.md' },
     ]);
-    assert.doesNotMatch(spilled, /Dereference a ref with/);
     closeDb();
 });
 test('a human message coalesces verbatim — a conversation turn, not a digest', () => {
     // A human typing directly into a node's box is a CONVERSATION TURN, so the
-    // dormant wake path must read identically to the live path: no "From … — N
-    // updates" header, no `[message]` kind tag. Every other sender keeps framing.
+    // dormant wake path must read identically to the live path: no card, no
+    // `<from>` section. Every other sender is digest content.
     const body = 'first line\n\nsecond paragraph';
-    const human = coalesce([
+    const human = onlyDelivery(coalesce([
         finalizeInboxEntry({ from: 'human', tier: 'normal', kind: 'message', label: 'first line', data: { body } }),
-    ]);
+    ]));
     assert.equal(human, body);
-    const agent = coalesce([
+    const agent = onlyDelivery(coalesce([
         finalizeInboxEntry({ from: 'mqifzplr-0753bde3', tier: 'normal', kind: 'message', label: 'go', data: { body: 'go' } }),
-    ]);
-    assert.match(agent, /^From mqifzplr-0753bde3 — 1 update:/);
+    ]));
+    assert.equal(agent.startsWith('<runtime kind="inbox"'), true);
+    assert.match(agent, /<from id="mqifzplr-0753bde3" updates="1">/);
+});
+test('a mixed batch splits: human words verbatim, node reports in one card, order preserved', () => {
+    // Concatenating the two into one message left `parseCard` unable to see the
+    // envelope, so the whole delivery read as the person's words.
+    const humanEntry = (body) => finalizeInboxEntry({ from: 'human', tier: 'normal', kind: 'message', label: body, data: { body } });
+    const nodeEntry = (from, body) => finalizeInboxEntry({ from, tier: 'normal', kind: 'update', label: body, data: { body } });
+    for (const [name, entries] of [
+        ['human first', [humanEntry('do the thing'), nodeEntry('mqifzplr-0753bde3', 'phase one done')]],
+        ['node first', [nodeEntry('mqifzplr-0753bde3', 'phase one done'), humanEntry('do the thing')]],
+    ]) {
+        const deliveries = coalesce([...entries]);
+        assert.equal(deliveries.length, 2, name);
+        // The card lands where its first sender fell.
+        assert.deepEqual(deliveries.map((d) => d.kind), name === 'human first' ? ['human', 'card'] : ['card', 'human'], name);
+        const human = deliveries.find((d) => d.kind === 'human');
+        assert.equal(human.text, 'do the thing', name);
+        assert.doesNotMatch(human.text, /<runtime|<from /, name);
+        const card = deliveries.find((d) => d.kind === 'card');
+        const parsed = parseCard({ role: 'user', content: card.text });
+        assert.notEqual(parsed, null, name);
+        assert.deepEqual(parsed.senders.map((sender) => sender.id), ['mqifzplr-0753bde3'], name);
+        assert.deepEqual(card.entries.map((entry) => entry.from), ['mqifzplr-0753bde3'], name);
+    }
 });
 let origTick;
 let origDebounce;
@@ -174,6 +225,22 @@ describe('canvas inbox watcher — finished-node delivery', () => {
         assert.equal(pi.injected.length, 1, 'one coalesced injection');
         assert.equal(pi.injected[0].deliverAs, 'steer', 'a finished node steers, not follows up');
     });
+    test('a mixed batch reaches pi as separate messages: the person verbatim, the card whole', async () => {
+        freshNode('node-mixed');
+        const pi = makeFakePi();
+        disposers.push(registerWatcher(pi));
+        await wait(TICK_MS + 100);
+        appendInbox('node-mixed', { from: 'human', tier: 'normal', kind: 'message', label: 'do the thing', data: { body: 'do the thing' } });
+        appendInbox('node-mixed', { from: 'child-9', tier: 'normal', kind: 'update', label: 'phase one done' });
+        // One visible send per cycle, so the second part lands a tick later.
+        await waitFor(() => pi.injected.length >= 2);
+        assert.equal(pi.injected.length, 2, 'the batch split into two visible messages');
+        assert.equal(pi.injected[0].content, 'do the thing', 'the person\'s words arrive verbatim');
+        assert.equal(parseCard({ role: 'user', content: pi.injected[0].content }), null, 'no envelope rides the human message');
+        const card = parseCard({ role: 'user', content: pi.injected[1].content });
+        assert.notEqual(card, null, 'the card message is a whole envelope');
+        assert.deepEqual(card.senders.map((sender) => sender.id), ['child-9']);
+    });
     test('mid-stream: a routine update still follows up', async () => {
         freshNode('node-update');
         const pi = makeFakePi();

package/dist/core/__tests__/human-deliver.test.js

@@ -7,15 +7,20 @@ import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from 'no
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createApiServer } from '../../daemon/api/server.js';
-import { cancelHumanTicket, deliverTerminalResult, resolvePageTicket } from '../../daemon/human/finish.js';
+import { cancelHumanTicket, deliverTerminalResult, resolvePageTicket, settleFeedbackCompanion } from '../../daemon/human/finish.js';
 import { humanSend } from '../../commands/human/prompts.js';
 import { getNode, listNodes, closeDb } from '../canvas/index.js';
-import { readInboxSince } from '../feed/inbox.js';
+import { coalesce, readInboxSince } from '../feed/inbox.js';
+import { createPageFeedbackComment } from '../human/feedback.js';
 import { resolveRef } from '../canvas/history.js';
+import { transition } from '../runtime/lifecycle.js';
+import { reviveNode } from '../runtime/revive.js';
 import { apiSocketPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { bindTicketReplyRoute } from '../human/convention.js';
 import { ticketDir } from '../human/root.js';
+import { pageFeedbackPath } from '../human/feedback.js';
+import { parseCard } from '../../shared/generated-context.js';
 import { readTicketResult, submitPage } from '../human/tickets.js';
 let home;
 let priorHome;
@@ -120,7 +125,7 @@ describe('enqueue is producer-only', () => {
     });
 });
 describe('terminal ticket delivery', () => {
-    test('resolvePageTicket pushFinals the readable answer once and wakes the subscribed parent', async () => {
+    test("resolvePageTicket pushFinals the person's words once and wakes the subscribed parent", async () => {
         const { parent, bridge } = bridgeUnder();
         const dir = submitBridgePage(bridge);
         const result = await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
@@ -130,8 +135,34 @@ describe('terminal ticket delivery', () => {
         const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
         assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
         const body = reportBody(finals[0].ref);
-        assert.ok(body.includes('“yes, ship”'), 'the readable slot answer is inlined in the report');
-        assert.ok(body.includes(join(dir, 'response.json')));
+        assert.equal(body, 'yes, ship');
+        assert.equal(finals[0].disposition, 'human-answer');
+        assert.ok(!body.includes(join(dir, 'response.json')));
+    });
+    test('settlement delivers feedback outside the human-answer entry', async () => {
+        const { parent, bridge } = bridgeUnder();
+        const dir = submitBridgePage(bridge);
+        writeFileSync(pageFeedbackPath(dir), JSON.stringify({
+            schema: 'crtr.page-feedback/v1',
+            companionNodeId: 'feedback-companion',
+            firstCommentedSha256: 'stale-page-hash',
+            comments: [],
+        }));
+        await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
+        closeDb();
+        const entries = readInboxSince(parent).filter((entry) => entry.from === bridge);
+        const final = entries.find((entry) => entry.kind === 'final');
+        const feedback = entries.find((entry) => entry.kind === 'update');
+        assert.ok(final);
+        assert.ok(feedback);
+        assert.equal(final.disposition, 'human-answer');
+        assert.match(reportBody(feedback.ref), /The page changed during feedback/);
+        const deliveries = coalesce(entries);
+        assert.equal(deliveries.length, 1);
+        const card = parseCard({ role: 'user', content: deliveries[0].text });
+        assert.ok(card);
+        const answer = card.senders.flatMap((sender) => sender.entries).find((entry) => entry.disposition === 'human-answer');
+        assert.deepEqual(answer, { kind: 'final', disposition: 'human-answer', body: 'yes, ship', ref: final.ref });
     });
     test('a replay against a terminal bridge is a no-op', async () => {
         const { parent, bridge } = bridgeUnder();
@@ -142,6 +173,36 @@ describe('terminal ticket delivery', () => {
         const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
         assert.equal(finals.length, 1, 'replay after a terminal bridge pushes nothing further');
     });
+    test('approved companions receive one canonical final while dismissed companions remain canceled', async () => {
+        const { bridge } = bridgeUnder();
+        const dir = submitBridgePage(bridge);
+        const companion = spawnNode({ kind: 'general', parent: bridge, cwd: home, name: 'feedback companion', lifecycle: 'resident' }).node_id;
+        createPageFeedbackComment(dir, { quote: 'Ship it?', note: 'Confirm the release.', companionNodeId: companion });
+        transition(companion, 'finish');
+        await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
+        const finalized = getNode(companion);
+        assert.equal(finalized.status, 'done');
+        assert.equal(finalized.intent, 'done');
+        assert.ok(finalized.final_report);
+        assert.ok(finalized.finalized_at);
+        const finalReport = finalized.final_report;
+        const finalizedAt = finalized.finalized_at;
+        await deliverTerminalResult(bridge);
+        assert.equal(getNode(companion)?.final_report, finalReport, 'terminal replay preserves the first canonical final');
+        assert.equal(getNode(companion)?.finalized_at, finalizedAt, 'terminal replay preserves the first finalization time');
+        assert.throws(() => reviveNode(companion, { resume: true }), /finalization latch/);
+        const { bridge: dismissedBridge } = bridgeUnder();
+        const dismissedDir = submitBridgePage(dismissedBridge);
+        const dismissedCompanion = spawnNode({ kind: 'general', parent: dismissedBridge, cwd: home, name: 'dismissed feedback companion', lifecycle: 'resident' }).node_id;
+        createPageFeedbackComment(dismissedDir, { quote: 'Ship it?', note: 'Do not ship.', companionNodeId: dismissedCompanion });
+        await cancelHumanTicket(dismissedBridge, { reason: 'dismissed', actor: 'human' });
+        assert.equal(getNode(dismissedCompanion)?.status, 'canceled');
+        assert.equal(getNode(dismissedCompanion)?.final_report, null);
+        const dismissedResult = readTicketResult(dismissedDir);
+        await settleFeedbackCompanion(dismissedBridge, dismissedResult.kind === 'canceled' ? 'canceled' : 'approved');
+        assert.equal(getNode(dismissedCompanion)?.status, 'canceled');
+        assert.equal(getNode(dismissedCompanion)?.final_report, null);
+    });
     test('cancelHumanTicket finishes the bridge and notifies non-actor subscribers', async () => {
         const actor = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' }).node_id;
         const bridge = spawnNode({ kind: 'human', parent: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;

package/dist/core/__tests__/serial/broker-snapshot-history.test.js

@@ -89,7 +89,8 @@ test('broker welcome snapshot serves the persisted history, not pi\u2019s sliced
         const sessionFile = seed.getSessionFile();
         assert.ok(sessionFile, 'seed session persisted a .jsonl');
         // The persisted, ordered history a dormant reader / crouter-web normalizer sees.
-        const persisted = SessionManager.open(sessionFile).buildSessionContext().messages;
+        const persistedManager = SessionManager.open(sessionFile);
+        const persisted = persistedManager.buildSessionContext().messages;
         assert.equal(persisted.length, 5, 'disk holds all five messages incl. the errored attempt');
         // 2. Revive: the broker resumes the closed session via the SERVICES path.
         const { session } = await buildBrokerSession(realEngine, {
@@ -113,9 +114,11 @@ test('broker welcome snapshot serves the persisted history, not pi\u2019s sliced
             //    a turn the .jsonl still holds. The fix serves the persisted history (5),
             //    byte-identical to the normalizer.
             const snap = snapshotMessages(session);
+            assert.ok(snap);
             assert.equal(snap.length, persisted.length, 'snapshot presents the COMPLETE persisted history (omit-on-revive regression)');
             assert.notEqual(snap.length, session.messages.length, 'snapshot does NOT echo the sliced live array');
-            assert.deepEqual(snap, persisted, 'snapshot is byte-identical to the static normalizer\u2019s buildSessionContext (single source of truth)');
+            assert.deepEqual(snap.map(({ message }) => message), persisted, 'snapshot is byte-identical to the static normalizer\u2019s buildSessionContext (single source of truth)');
+            assert.deepEqual(snap.map(({ id }) => id), persistedManager.getEntries().map(({ id }) => id), 'snapshot ids stay aligned to the persisted entry that projected each message');
         }
         finally {
             session.dispose();

package/dist/core/__tests__/serial/deferred-no-wake.test.js

@@ -486,10 +486,13 @@ test('the real inbox watcher holds a deferred entry alone, then delivers it TOGE
             label: 'go now',
             data: { body: 'go now' },
         });
-        await wait(SETTLE_MS);
-        assert.equal(pi.injected.length, 1, 'both entries are delivered together in ONE coalesced turn once a non-deferred entry joins the batch');
-        assert.match(pi.injected[0].content, /deferred note/, 'the previously-held deferred entry rides along — not lost');
-        assert.match(pi.injected[0].content, /go now/, 'the new normal entry is in the same digest — not duplicated into a second turn');
+        await wait(SETTLE_MS + TICK_MS * 2);
+        // Two direct human entries are two verbatim deliveries — one message per
+        // entry, physical order preserved, one visible send per watcher cycle.
+        assert.equal(pi.injected.length, 2, 'both entries are delivered once a non-deferred entry joins the batch — each human entry as its own verbatim message');
+        assert.match(pi.injected[0].content, /deferred note/, 'the previously-held deferred entry is delivered first — not lost');
+        assert.doesNotMatch(pi.injected[0].content, /go now/, 'the deliveries are separate messages, not one concatenation');
+        assert.match(pi.injected[1].content, /go now/, 'the new normal entry follows in its own message — not duplicated');
         assert.equal(pi.injected[0].deliverAs, undefined, 'idle delivery triggers a fresh turn, no deliverAs');
         // Idle-path delivery hands off on the void send but only COMMITS the
         // durable cursor at agent_settled (never on the fire-and-forget send

package/dist/core/__tests__/serial/flagship-lifecycle.test.js

@@ -59,6 +59,7 @@ import { subscribe } from '../../canvas/canvas.js';
 import { transition } from '../../runtime/lifecycle.js';
 import { pushFinal } from '../../feed/feed.js';
 import { evaluateStop, STALL_REPROMPT } from '../../runtime/stop-guard.js';
+import { formatCard } from '../../../shared/generated-context.js';
 import { personaDrift, commitPersonaAck } from '../../runtime/persona.js';
 // A pid reaped (dead) by the time spawnSync returns — a released broker's exited
 // process (the headless analog of a closed pane).
@@ -228,7 +229,7 @@ test('flagship: full node lifecycle — spawn, dormancy, one-hop wake, promote,
             const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
             assert.equal(stop.action, 'reprompt', 'orchestrator B with no live sub, no final → reprompt');
             assert.equal(stop.reason, 'stalled', 'classified stalled');
-            assert.equal(stop.action === 'reprompt' ? stop.message : '', STALL_REPROMPT, 'the stall reprompt nudge');
+            assert.equal(stop.action === 'reprompt' ? stop.message : '', formatCard('stop-guard', { reason: 'stalled' }, STALL_REPROMPT), 'the stall reprompt nudge, delivered as a whole-message stop-guard envelope');
         }
         // ===================================================================
         // S10 — B YIELDS. The real plain `node yield` verb sets intent=refresh

package/dist/core/__tests__/serial/human-deliver-e2e.test.js

@@ -121,8 +121,11 @@ test('the ticket resolve route pushFinals the readable answer to the parent', as
     assert.equal(getNode(bridge)?.status, 'done', 'bridge finalized by crtrd');
     const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
     assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
+    // A typed answer's final is purely the person's words, attributed by the
+    // human-answer disposition — no record path, no "Answered …" trailer.
+    assert.equal(finals[0].disposition, 'human-answer');
     const body = reportBody(finals[0].ref);
     assert.ok(body.includes('yes, ship'));
-    assert.ok(body.includes(join(dir, 'response.json')));
+    assert.ok(!body.includes(join(dir, 'response.json')));
     assert.ok(!body.includes('humanloop.response/v2'));
 });

package/dist/core/__tests__/serial/revive.test.js

@@ -39,7 +39,8 @@ import { closeDb } from '../../canvas/db.js';
 import { buildPiArgv } from '../../runtime/launch.js';
 import { headlessBrokerHost } from '../../runtime/host.js';
 import { resumeArgs, reviveNode } from '../../runtime/revive.js';
-import { REVIVE_KICKOFF_SENTINEL, readGoal, writeGoal } from '../../runtime/kickoff.js';
+import { readGoal, writeGoal } from '../../runtime/kickoff.js';
+import { parseCard } from '../../../shared/generated-context.js';
 import { seedRoadmap } from '../../runtime/roadmap.js';
 import { InputError } from '../../io.js';
 import { createHarness } from '../helpers/harness.js';
@@ -59,6 +60,10 @@ function node(id, over = {}) {
         ...over,
     };
 }
+/** A launch prompt is the fresh-revive kickoff when it carries that card kind. */
+function isReviveKickoff(arg) {
+    return parseCard({ role: 'user', content: arg })?.kind === 'revive';
+}
 /** A pid that is guaranteed dead — a crashed broker the guard must NOT see as up. */
 function deadPid() {
     const r = spawnSync('true', [], { stdio: 'ignore' });
@@ -487,7 +492,7 @@ test('an unstarted node relaunches as a birth, not a "revived fresh" kickoff', (
         createNode(node('bare-unstarted', { cwd: home, pi_session_id: 'uuid-a', pi_session_file: missing }));
         reviveNode('bare-unstarted', { resume: true });
         const bare = launches[0];
-        assert.equal(bare.some((a) => a.startsWith(REVIVE_KICKOFF_SENTINEL)), false, 'an unstarted node is never told it lost context it never had');
+        assert.equal(bare.some((a) => isReviveKickoff(a)), false, 'an unstarted node is never told it lost context it never had');
         assert.deepEqual(bare, buildPiArgv(getNode('bare-unstarted'), {}).argv, 'a promptless boot — the argv carries no trailing prompt positional at all');
         // (2) Spawned with a mandate whose first turn never persisted: replay it.
         createNode(node('mandate-unstarted', { cwd: home, pi_session_id: 'uuid-b', pi_session_file: missing }));
@@ -498,7 +503,7 @@ test('an unstarted node relaunches as a birth, not a "revived fresh" kickoff', (
         createNode(node('progressed', { cwd: home, pi_session_id: 'uuid-c', pi_session_file: missing }));
         seedRoadmap('progressed', { goal: 'ship it' });
         reviveNode('progressed', { resume: true });
-        assert.equal(launches[2].at(-1).startsWith(REVIVE_KICKOFF_SENTINEL), true, 'a node with a roadmap still rebuilds from the kickoff');
+        assert.equal(isReviveKickoff(launches[2].at(-1)), true, 'a node with a roadmap still rebuilds from the kickoff');
     }
     finally {
         headlessBrokerHost.launch = originalLaunch;

package/dist/core/__tests__/session-cycles.test.js

@@ -75,15 +75,17 @@ test('cycleAwareMessages: a compacted prior cycle replays via buildSessionContex
     // Minimal fake mirroring the real SDK's SessionManager just enough to drive
     // cycleAwareMessages: buildSessionContext() plus the tree accessors it reads.
     const out = cycleAwareMessages(cycleManager(entries, 'm4'));
-    const summaries = out.filter((m) => m.role === 'compactionSummary');
+    assert.ok(out);
+    const summaries = out.filter(({ message }) => message.role === 'compactionSummary');
     assert.equal(summaries.length, 1, 'exactly one compactionSummary message from the replayed prior cycle');
-    const texts = out.map((m) => (typeof m.content === 'string' ? m.content : ''));
+    const texts = out.map(({ message }) => (typeof message.content === 'string' ? message.content : ''));
     assert.ok(!texts.some((t) => t.includes('pre-compaction message')), 'the pre-compaction raw message (m1) must NOT appear');
     assert.ok(texts.some((t) => t.includes('kept message')), 'the kept message (m2) DOES appear');
     assert.ok(texts.some((t) => t.includes('cycle 0 leaf at yield')), 'the post-compaction message (m3) DOES appear');
     assert.ok(texts.some((t) => t.includes('cycle 1 live message')), 'the live cycle (m4) DOES appear');
-    const dividers = out.filter((m) => m.customType === 'crtr-cycle-divider');
+    const dividers = out.filter(({ message }) => message.customType === 'crtr-cycle-divider');
     assert.equal(dividers.length, 1, 'one divider between the replayed prior cycle and the live one');
+    assert.equal(dividers[0].id, 'cy1~divider', 'the synthesized divider stays tied to its cycle marker');
 });
 test('cycleAwareMessages: a yielded cycle keeps terminal assistant content without an abort notice', () => {
     const m1 = userMsg('m1', null, 'yield after this turn');
@@ -99,11 +101,12 @@ test('cycleAwareMessages: a yielded cycle keeps terminal assistant content witho
     };
     const m3 = userMsg('m3', 'cy1', 'fresh cycle');
     const out = cycleAwareMessages(cycleManager([m1, m2, cy1, m3], 'm3'));
-    const yieldedAssistant = out.find((message) => message.role === 'assistant');
+    assert.ok(out);
+    const yieldedAssistant = out.find(({ message }) => message.role === 'assistant').message;
     assert.deepEqual(yieldedAssistant.content, [toolCall], 'the yielded turn remains available to transcript renderers');
     assert.equal(yieldedAssistant.stopReason, undefined, 'yield is not presented as a failed assistant turn');
     assert.equal(yieldedAssistant.errorMessage, undefined, 'the provider abort text is omitted with the yield boundary');
-    assert.equal(out.filter((message) => message.customType === 'crtr-cycle-divider').length, 1);
+    assert.equal(out.filter(({ message }) => message.customType === 'crtr-cycle-divider').length, 1);
 });
 // Observed shape: the yield's self-abort landed as the NEXT request was
 // starting, so the provider caught a bare AbortError instead of seeing its own
@@ -123,7 +126,8 @@ test('cycleAwareMessages: a yield abort recorded as a provider error is still no
     };
     const m3 = userMsg('m3', 'cy1', 'fresh cycle');
     const out = cycleAwareMessages(cycleManager([m1, m2, cy1, m3], 'm3'));
-    const yieldedAssistant = out.find((message) => message.role === 'assistant');
+    assert.ok(out);
+    const yieldedAssistant = out.find(({ message }) => message.role === 'assistant').message;
     assert.equal(yieldedAssistant.stopReason, undefined, 'yield is not presented as a failed assistant turn');
     assert.equal(yieldedAssistant.errorMessage, undefined, 'the aborted-request text is omitted with the yield boundary');
 });

package/dist/core/canvas/render-source.js

@@ -20,6 +20,7 @@ import { jobDir, contextDir } from './paths.js';
 import { isPidAlive } from './pid.js';
 import { resolveNodeVisual, faultSummary } from './status-glyph.js';
 import { readFault } from '../runtime/fault.js';
+import { isLegacyRuntimeText, parseCard } from '../../shared/generated-context.js';
 // ---------------------------------------------------------------------------
 // Active-fault overlay: stale daemon-owned provider faults are hidden once the
 // broker pid is gone; manual/client faults stay visible until cleared.
@@ -191,6 +192,8 @@ export function readSessionParts(sessionFile) {
         const text = extractUserText(rec.message.content);
         if (text === '')
             continue;
+        if (parseCard({ role: 'user', content: text }) !== null || isLegacyRuntimeText(text))
+            continue;
         const capped = text.length > CONVO_MSG_CAP ? text.slice(0, CONVO_MSG_CAP) : text;
         parts.push(capped);
         total += capped.length + 1;

package/dist/core/feed/feed.d.ts

@@ -1,8 +1,11 @@
+import type { InboxDisposition } from './inbox.js';
 export type PushKind = 'update' | 'urgent' | 'final';
 export interface PushOpts {
     kind: PushKind;
     body: string;
     from?: string;
+    /** Attribution snapshotted by the human-ticket settlement paths; absent means an ordinary report. */
+    disposition?: InboxDisposition;
 }
 export interface PushResult {
     reportPath: string;
@@ -28,6 +31,9 @@ export declare function pushUrgent(nodeId: string, body: string, opts?: {
 }): Promise<PushResult>;
 export declare function pushFinal(nodeId: string, body: string, opts?: {
     from?: string;
+    disposition?: InboxDisposition;
 }): Promise<PushResult>;
 /** Re-fan a previously committed final to its ticket origin without finalizing again. */
-export declare function redeliverFinalReport(nodeId: string, originNodeId: string, reportBasename: string, body: string): PushResult;
+export declare function redeliverFinalReport(nodeId: string, originNodeId: string, reportBasename: string, body: string, opts?: {
+    disposition?: InboxDisposition;
+}): PushResult;