@north-light/crouter 0.3.170 → 0.3.172

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

@@ -1,25 +1,14 @@
 // Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-context-intro.test.ts
 //
-// BUG REGRESSION (crouter/CLAUDE.md testing policy):
-//   `crtr node new --fork-from <node>` caused AGENT IDENTITY CONFUSION. A fork
-//   inherits the SOURCE node's entire first-person conversation (pi COPIES it
-//   into the fork's session), so on boot the forked agent impersonated the
-//   source — it kept acting AS the source, even "monitoring itself" as a phantom
-//   child, until it happened to check CRTR_NODE_ID. Two root causes, both fixed
-//   here and pinned by these tests:
-//     1. canvas-context-intro never re-asserted the node's OWN identity, so the
-//        copied first-person narrative won.
-//     2. the idempotency guard misfired for a fork: the copied conversation
-//        already carries the SOURCE's <crtr-context> entry, so the guard treated
-//        it as "already present" and SUPPRESSED the fork's own intro entirely —
-//        the fork booted with the source's bearings (source id, source dir).
-//   Symptom write-up: nodes/mq4ns376-da6e56c9/reports/20260608T075810-final.md.
+// A fresh branch receives the full context baseline. A forked crouter branch
+// receives a compact node-scoped update after its inherited baseline. Resumes
+// remain idempotent through the exact node-id stamp.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { buildContextIntro, registerCanvasContextIntro, CONTEXT_INTRO_CUSTOM_TYPE, } from '../canvas-context-intro.js';
+import { buildContextIntro, buildForkContextIntro, registerCanvasContextIntro, CONTEXT_INTRO_CUSTOM_TYPE, } from '../canvas-context-intro.js';
 import { createNode } from '../../core/canvas/canvas.js';
 import { closeDb } from '../../core/canvas/db.js';
 let home;
@@ -82,56 +71,44 @@ after(() => {
     else
         process.env['CRTR_NODE_ID'] = origNode;
 });
-test('boot intro asserts the node\'s OWN identity up front (regression: forked node impersonated source)', () => {
+test('full boot intro leads with the node\'s own identity', () => {
     createNode(node('alpha', { name: 'fix-auth', kind: 'developer' }));
     const intro = buildContextIntro('alpha');
     assert.match(intro, /<crtr-bearings>/, 'opens with the bearings section');
     assert.match(intro, /You are node alpha/, 'names the node by its own id');
     assert.match(intro, /kind developer/, 'states the node kind');
-    // Gated (Option A): a fresh (non-fork) node's bearings are its FIRST entry, so
-    // there is no earlier narrative to disown — the disown framing (the fork callout
-    // naming the copied history "inherited reference material") is fork-only and must
-    // NOT appear here.
-    assert.ok(!/inherited reference material/.test(intro), 'a non-fork node carries no disown-the-earlier-narrative line');
-    // Identity LEADS the bearings block (no wrapper of its own), so it is the first
-    // prose the model reads — the orienting frame, not a trailing note.
+    assert.doesNotMatch(intro, /FORK of/, 'a fresh node carries no fork framing');
+    // Identity leads the bearings block.
     assert.match(intro, /<crtr-bearings>\nYou are node alpha/, 'identity leads the bearings block');
     assert.ok(intro.indexOf('<crtr-bearings>') < intro.indexOf('<project_context>'), 'bearings precede project context');
 });
-test('a FORK\'s intro names the source and disowns it (regression: fork acted AS the source)', () => {
-    // The source node whose conversation pi copied into the fork.
+test('fork bearings contain only the new node-scoped facts', () => {
     createNode(node('src7', { name: 'looking-pi-crouter', description: 'monitor-telemetry' }));
-    // The fork: fork_from provenance persisted at spawn.
-    createNode(node('fork9', { fork_from: 'src7' }));
-    const intro = buildContextIntro('fork9');
-    assert.match(intro, /You are node fork9/, 'the fork is told its OWN id');
-    assert.match(intro, /You are a FORK of src7/, 'names the fork source explicitly');
-    assert.match(intro, /You are NOT src7/, '"you are NOT the source" flag is present');
-    // Carries the source's human label so the agent recognizes the copied persona.
-    assert.match(intro, /looking-pi-crouter/, 'surfaces the source label');
-    // The fork DOES carry the disown framing — it has a real referent (copied history).
-    assert.match(intro, /inherited reference material/, 'the fork disowns the copied first-person narrative');
-    // It must NOT tell the fork it is the source node.
-    assert.ok(!/You are node src7/.test(intro), 'fork is never told it is the source node');
-    // A non-fork sibling gets the identity assertion but NO fork callout and NO
-    // disown line (gated on fork_from).
+    createNode(node('fork9', { fork_from: 'src7', lifecycle: 'resident' }));
+    const intro = buildForkContextIntro('fork9');
+    assert.match(intro, /You are node fork9/, 'the fork receives its own id');
+    assert.match(intro, /new FORK of src7/, 'the fork names its source');
+    assert.match(intro, /not src7/, 'the fork does not adopt the source identity');
+    assert.match(intro, /looking-pi-crouter/, 'the source label identifies the copied history');
+    assert.match(intro, /Lifecycle: resident/, 'the fork receives its current lifecycle');
+    assert.match(intro, /independent root/, 'the fork receives its current graph role');
+    assert.ok(intro.includes(join(home, 'nodes', 'fork9', 'context')), 'the fork receives its own context path');
+    assert.match(intro, /first real user message/, 'the fork waits for its new mandate');
+    assert.doesNotMatch(intro, /<memory kind="knowledge">/, 'the inherited knowledge catalog is not repeated');
+    assert.doesNotMatch(intro, /<auto-loaded-context>/, 'inherited workspace docs are not repeated');
+    assert.doesNotMatch(intro, /<project_context>/, 'the inherited project snapshot is not repeated');
     createNode(node('plain2'));
     const plain = buildContextIntro('plain2');
     assert.match(plain, /You are node plain2/);
-    assert.ok(!/FORK of/.test(plain), 'a fresh (non-fork) node carries no fork callout');
-    assert.ok(!/inherited reference material/.test(plain), 'a non-fork node carries no disown line');
-    // Regression: a raw provenance FILE PATH as fork_from (as human-work queue
-    // handlers pass) must not crash getNode() lookup inside identity assertion
-    // construction — it is not a valid node-id path segment, so it must be
-    // treated as an opaque source label instead of thrown at.
+    assert.ok(!/FORK of/.test(plain), 'a fresh node carries no fork callout');
+    // A path-valued provenance remains an opaque label.
     const pathSource = '/Users/silasrhyneer/.crouter/canvas/human-work/queue/20260717T000000-abc.json';
     createNode(node('fork10', { fork_from: pathSource }));
-    const pathIntro = buildContextIntro('fork10');
-    assert.match(pathIntro, /You are node fork10/, 'the fork is told its OWN id');
-    assert.match(pathIntro, new RegExp(`You are a FORK of ${pathSource.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`), 'a path-valued fork source passes through as-is (no crash on getNode lookup)');
-    assert.match(pathIntro, /inherited reference material/, 'the fork disowns the copied first-person narrative');
+    const pathIntro = buildForkContextIntro('fork10');
+    assert.match(pathIntro, /You are node fork10/);
+    assert.match(pathIntro, new RegExp(`new FORK of ${pathSource.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`), 'a path-valued source is named without a node lookup');
 });
-test('session_start INJECTS the fork\'s own bearings despite the inherited source block (the misfiring-idempotency bug)', () => {
+test('session_start appends compact fork bearings after an inherited source baseline', () => {
     createNode(node('srcA'));
     createNode(node('forkB', { fork_from: 'srcA' }));
     // A fork boots with the SOURCE's whole conversation copied in — including the
@@ -141,22 +118,24 @@ test('session_start INJECTS the fork\'s own bearings despite the inherited sourc
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
     pi.fireSessionStart([inheritedSourceBlock]);
-    // The fix: the inherited block belongs to srcA, so it must NOT suppress
-    // forkB's own intro. forkB's bearings (with its identity assertion) ARE sent.
+    // The inherited baseline belongs to srcA, so forkB receives its own compact update.
     assert.equal(pi.sent.length, 1, 'fork injects its OWN bearings over the inherited source block');
     assert.equal(pi.sent[0].customType, CONTEXT_INTRO_CUSTOM_TYPE);
     assert.match(pi.sent[0].content, /You are node forkB/, 'injected bearings name the fork, not the source');
-    assert.match(pi.sent[0].content, /You are a FORK of srcA/, 'injected bearings carry the fork callout');
-    // The exact, machine-readable resume discriminator rides along (not sent to
-    // the LLM): it names THIS node, so a later resume tells our block apart from
-    // any inherited one without depending on prose.
-    assert.equal(pi.sent[0].details?.nodeId, 'forkB', 'injected block carries the exact node-id stamp');
+    assert.match(pi.sent[0].content, /new FORK of srcA/, 'injected bearings carry the fork callout');
+    assert.doesNotMatch(pi.sent[0].content, /<project_context>/, 'the full source baseline is not repeated');
+    assert.equal(pi.sent[0].details?.nodeId, 'forkB', 'the compact update carries the fork node stamp');
+    // A non-crouter source has no inherited baseline, so its fork receives one.
+    createNode(node('externalF', { fork_from: '/tmp/external-session.jsonl' }));
+    process.env['CRTR_NODE_ID'] = 'externalF';
+    const externalPi = makeFakePi();
+    registerCanvasContextIntro(externalPi);
+    externalPi.fireSessionStart([]);
+    assert.match(externalPi.sent[0].content, /<project_context>/, 'an external-session fork receives the full baseline');
 });
-test('resume idempotency uses the EXACT details stamp, independent of block text (regression hardening)', () => {
+test('resume idempotency uses the exact details stamp independent of block text', () => {
     createNode(node('stampD'));
-    // A restored block that carries OUR exact stamp but whose TEXT does not mention
-    // our id. The old content-substring-only guard would re-inject (and accumulate)
-    // here; the exact `details.nodeId` match skips correctly.
+    // The exact node-id stamp is authoritative even when prose carries no id.
     const stampedNoIdInText = {
         type: 'custom_message',
         customType: CONTEXT_INTRO_CUSTOM_TYPE,
@@ -169,10 +148,9 @@ test('resume idempotency uses the EXACT details stamp, independent of block text
     pi.fireSessionStart([stampedNoIdInText]);
     assert.equal(pi.sent.length, 0, 'exact details-stamp match skips re-injection even when the text omits the id');
 });
-test('session_start stays IDEMPOTENT on a genuine resume (our own bearings already present)', () => {
+test('session_start stays idempotent on a genuine resume', () => {
     createNode(node('resumeC'));
-    // A `--session` relaunch restores OUR conversation — our own bearings (naming
-    // resumeC) are already in history.
+    // A resume restores this node's already-stamped bearings.
     const ownBlock = introEntry(buildContextIntro('resumeC'));
     process.env['CRTR_NODE_ID'] = 'resumeC';
     const pi = makeFakePi();

package/dist/pi-extensions/__tests__/canvas-recap.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-recap.test.js

@@ -0,0 +1,159 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { registerCanvasRecap } from '../canvas-recap.js';
+import { createNode } from '../../core/canvas/canvas.js';
+import { closeDb } from '../../core/canvas/db.js';
+test('a streaming manual recap snapshots the partial response and replaces the pinned recap only on success', () => {
+    const originalNodeId = process.env['CRTR_NODE_ID'];
+    process.env['CRTR_NODE_ID'] = 'recap-regression-node';
+    const handlers = new Map();
+    let commandHandler;
+    const widgetWrites = [];
+    const notifications = [];
+    const generations = [];
+    let idleWaits = 0;
+    const recapGenerator = (conversation, finish) => {
+        generations.push({ conversation, finish });
+    };
+    const pi = {
+        on: (event, handler) => { handlers.set(event, handler); },
+        registerCommand: (_name, options) => {
+            commandHandler = options.handler;
+        },
+    };
+    const sessionManager = {
+        getEntries: () => [{ type: 'message', message: { role: 'user', content: 'Build the recap command.' } }],
+    };
+    const ctx = {
+        ui: {
+            setWidget: (_key, content) => { widgetWrites.push(content); },
+            notify: (message) => { notifications.push(message); },
+        },
+        sessionManager,
+        model: { provider: 'test', id: 'light' },
+        isIdle: () => false,
+        waitForIdle: async () => { idleWaits += 1; },
+    };
+    try {
+        registerCanvasRecap(pi, recapGenerator);
+        handlers.get('session_start')?.({}, ctx);
+        commandHandler?.('', ctx);
+        assert.equal(notifications.at(-1), 'Generating recap…', 'the manually selected command confirms that generation started');
+        generations[0]?.finish('Goal: Existing goal\nState: Existing state');
+        assert.deepEqual(widgetWrites.at(-1), ['Goal: Existing goal', 'State: Existing state']);
+        assert.equal(notifications.at(-1), 'Recap ready', 'a completed manual recap confirms that the widget was refreshed');
+        handlers.get('message_update')?.({
+            message: { role: 'assistant', content: [{ type: 'text', text: 'I am editing the live implementation now.' }] },
+        }, ctx);
+        const writesBeforeRequest = widgetWrites.length;
+        const result = commandHandler?.('', ctx);
+        assert.equal(result, undefined, 'the command starts synchronously while the main response is streaming');
+        assert.equal(idleWaits, 0);
+        assert.equal(generations.length, 2);
+        assert.match(generations[1].conversation, /Agent: I am editing the live implementation now\./);
+        assert.equal(widgetWrites.length, writesBeforeRequest, 'the pinned recap remains while its replacement generates');
+        handlers.get('message_update')?.({
+            message: { role: 'assistant', content: [{ type: 'text', text: 'I am now verifying the implementation.' }] },
+        }, ctx);
+        generations[1].finish('Goal: Updated goal\nState: Updated click-time state');
+        assert.deepEqual(widgetWrites.at(-1), ['Goal: Updated goal', 'State: Updated click-time state']);
+    }
+    finally {
+        handlers.get('session_shutdown')?.({}, ctx);
+        if (originalNodeId === undefined)
+            delete process.env['CRTR_NODE_ID'];
+        else
+            process.env['CRTR_NODE_ID'] = originalNodeId;
+    }
+});
+test('review recap and naming input exclude inherited entries while retaining the post-boundary conversation', () => {
+    const originalNodeId = process.env['CRTR_NODE_ID'];
+    const originalHome = process.env['CRTR_HOME'];
+    const home = mkdtempSync(join(tmpdir(), 'crtr-recap-boundary-'));
+    const nodeId = 'review-recap-node';
+    const handlers = new Map();
+    let commandHandler;
+    const widgetWrites = [];
+    const recapInputs = [];
+    const namingInputs = [];
+    let entries = [
+        { type: 'message', message: { role: 'user', content: 'PREBOUNDARY_CANARY inherited request' } },
+        { type: 'message', message: { role: 'assistant', content: 'inherited answer' } },
+        {
+            type: 'custom_message',
+            customType: 'crtr-review-boundary',
+            details: { reviewId: 'review-1' },
+        },
+        { type: 'message', message: { role: 'user', content: 'review-only finding' } },
+        { type: 'message', message: { role: 'assistant', content: 'review-only resolution' } },
+    ];
+    const pi = {
+        on: (event, handler) => { handlers.set(event, handler); },
+        registerCommand: (_name, options) => {
+            commandHandler = options.handler;
+        },
+        getSessionName: () => 'developer',
+        setSessionName: () => undefined,
+    };
+    const sessionManager = { getEntries: () => entries };
+    const ctx = {
+        ui: { setWidget: (_key, content) => { widgetWrites.push(content); } },
+        sessionManager,
+    };
+    const recapGenerator = (conversation) => { recapInputs.push(conversation); };
+    try {
+        closeDb();
+        process.env['CRTR_HOME'] = home;
+        process.env['CRTR_NODE_ID'] = nodeId;
+        createNode({
+            node_id: nodeId,
+            name: 'developer',
+            created: new Date().toISOString(),
+            cwd: '/tmp/work',
+            kind: 'developer',
+            mode: 'base',
+            lifecycle: 'terminal',
+            status: 'active',
+            review_binding: {
+                review_id: 'review-1',
+                origin_node_id: 'origin',
+                branch_file: '/tmp/review.jsonl',
+                target_file: '/tmp/target.ts',
+            },
+        });
+        registerCanvasRecap(pi, recapGenerator, (_id, conversation) => { namingInputs.push(conversation); });
+        handlers.get('session_start')?.({}, ctx);
+        commandHandler?.('', ctx);
+        assert.equal(recapInputs.length, 1);
+        assert.equal(namingInputs.length, 1);
+        for (const input of [...recapInputs, ...namingInputs]) {
+            assert.doesNotMatch(input, /PREBOUNDARY_CANARY/);
+            assert.match(input, /review-only finding/);
+            assert.match(input, /review-only resolution/);
+        }
+        entries = [{ type: 'message', message: { role: 'user', content: 'PREBOUNDARY_CANARY without a boundary' } }];
+        handlers.get('message_update')?.({
+            message: { role: 'assistant', content: 'PREBOUNDARY_CANARY streaming response without a boundary' },
+        }, ctx);
+        commandHandler?.('', ctx);
+        assert.equal(recapInputs.length, 1, 'a markerless review produces no recap input, including a streaming partial');
+        assert.equal(namingInputs.length, 1, 'a markerless review produces no naming input, including a streaming partial');
+        assert.equal(widgetWrites.at(-1), undefined, 'a markerless review clears the recap widget');
+    }
+    finally {
+        handlers.get('session_shutdown')?.({}, ctx);
+        closeDb();
+        rmSync(home, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = originalHome;
+        if (originalNodeId === undefined)
+            delete process.env['CRTR_NODE_ID'];
+        else
+            process.env['CRTR_NODE_ID'] = originalNodeId;
+    }
+});

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

@@ -90,44 +90,6 @@ after(() => {
     else
         process.env['TMUX_PANE'] = origPane;
 });
-test('pending private fork binds both child coordinates atomically, or shuts down unbound', () => {
-    createNode(node('bound', {
-        private_fork_phase: 'fork_pending',
-        human_work_target: { work_kind: 'follow_up', dir: '/ticket', request_id: 'request-1', root: '/root' },
-        private_fork_recipe: { kickoff: 'private kickoff' },
-    }));
-    process.env['CRTR_NODE_ID'] = 'bound';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let boundShutdown = false;
-    pi.fire('session_start', { type: 'session_start' }, {
-        sessionManager: { getSessionId: () => 'child-id', getSessionFile: () => '/sessions/child.jsonl' },
-        shutdown: () => { boundShutdown = true; },
-    });
-    const bound = getNode('bound');
-    assert.equal(bound.private_fork_phase, 'session_started');
-    assert.equal(bound.pi_session_id, 'child-id');
-    assert.equal(bound.pi_session_file, '/sessions/child.jsonl');
-    assert.equal(boundShutdown, false, 'a fully-bound child remains live');
-    createNode(node('unbound', {
-        private_fork_phase: 'fork_pending',
-        human_work_target: { work_kind: 'follow_up', dir: '/ticket', request_id: 'request-2', root: '/root' },
-        private_fork_recipe: { kickoff: 'private kickoff' },
-    }));
-    process.env['CRTR_NODE_ID'] = 'unbound';
-    const missing = makeFakePi();
-    registerCanvasStophook(missing);
-    let missingShutdown = false;
-    missing.fire('session_start', { type: 'session_start' }, {
-        sessionManager: { getSessionId: () => 'child-id', getSessionFile: () => null },
-        shutdown: () => { missingShutdown = true; },
-    });
-    const unbound = getNode('unbound');
-    assert.equal(missingShutdown, true, 'a pending fork with no writable child session is shut down');
-    assert.equal(unbound.private_fork_phase, 'fork_pending');
-    assert.equal(unbound.pi_session_id ?? null, null);
-    assert.equal(unbound.pi_session_file ?? null, null);
-});
 test('natural stop commits idle-release only at agent_settled', { timeout: 1_000 }, () => {
     createNode(node('root', { parent: null, lifecycle: 'resident' }));
     createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
@@ -181,6 +143,22 @@ test('gh-451: idle-release does NOT release while a non-deferred inbox entry sit
     assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while a non-deferred entry is unseen');
     assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can still deliver/commit');
 });
+test('gh-451: finished does NOT shut down while a non-deferred inbox entry sits past the cursor', { timeout: 1_000 }, () => {
+    // A canonical final can settle while the in-process watcher has delivered a
+    // child report into the inbox but has not yet committed the durable cursor.
+    // The finished branch must keep this broker alive for that delivery.
+    createNode(node('mgr', { parent: null, lifecycle: 'terminal', final_report: 'mgr-final.md' }));
+    appendInbox('mgr', { from: 'worker', tier: 'normal', kind: 'update', label: 'worker made progress' });
+    process.env['CRTR_NODE_ID'] = 'mgr';
+    const pi = makeFakePi();
+    registerCanvasStophook(pi);
+    let shutdown = false;
+    const ctx = { shutdown: () => { shutdown = true; } };
+    settle(pi, stopEvent('already finalized'), ctx);
+    assert.equal(getNode('mgr')?.status, 'active', 'mgr stays active while the watcher catches up');
+    assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while a non-deferred entry is unseen');
+    assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can still deliver/commit');
+});
 test('gh-451: a DEFERRED-only unseen entry does not block idle-release (matches the daemon\'s own wake gate)', { timeout: 1_000 }, () => {
     createNode(node('root', { parent: null, lifecycle: 'resident' }));
     createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));

package/dist/pi-extensions/__tests__/canvas-structured-output.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-structured-output.test.js

@@ -0,0 +1,63 @@
+// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-structured-output.test.ts
+//
+// Regression: Codex strict function schemas require every property in `required`.
+import { after, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { convertResponsesTools } from '@earendil-works/pi-ai/api/openai-responses-shared';
+import { writeOutputSchema } from '../../core/runtime/structured-output.js';
+import registerCanvasStructuredOutput from '../canvas-structured-output.js';
+const previous = {
+    home: process.env['CRTR_HOME'],
+    nodeId: process.env['CRTR_NODE_ID'],
+};
+let home;
+after(() => {
+    if (home !== undefined)
+        rmSync(home, { recursive: true, force: true });
+    if (previous.home === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previous.home;
+    if (previous.nodeId === undefined)
+        delete process.env['CRTR_NODE_ID'];
+    else
+        process.env['CRTR_NODE_ID'] = previous.nodeId;
+});
+test('optional submit fields remain optional through a strict provider tool schema', () => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-structured-output-'));
+    process.env['CRTR_HOME'] = home;
+    process.env['CRTR_NODE_ID'] = 'structured-output-test';
+    const schema = {
+        type: 'object',
+        properties: {
+            status: { type: 'string' },
+            commit: { type: 'string' },
+            verification: { type: 'string' },
+            blocker: { type: 'string' },
+        },
+        required: ['status', 'verification'],
+        additionalProperties: false,
+    };
+    writeOutputSchema('structured-output-test', 'oneoff', schema);
+    let definition;
+    registerCanvasStructuredOutput({
+        registerTool(tool) {
+            definition = tool;
+        },
+        on() { },
+    });
+    assert.ok(definition, 'the pending request registers submit');
+    const parameters = definition['parameters'];
+    assert.deepEqual(parameters.required, ['status', 'commit', 'verification', 'blocker']);
+    assert.deepEqual(parameters.properties.commit, { anyOf: [{ type: 'string' }, { type: 'null' }] });
+    assert.deepEqual(parameters.properties.blocker, { anyOf: [{ type: 'string' }, { type: 'null' }] });
+    assert.deepEqual(schema.required, ['status', 'verification'], 'the stored request keeps its original optionality');
+    const [providerTool] = convertResponsesTools([definition], {
+        strict: false,
+        supportsStrictMode: true,
+    });
+    assert.equal(providerTool['strict'], true);
+});

package/dist/pi-extensions/canvas-context-intro.d.ts

@@ -66,10 +66,12 @@ interface PiLike {
         expanded?: boolean;
     }, theme: ThemeLike) => ComponentLike | undefined) => void;
 }
-/** Build the <crtr-context> bearings block for `nodeId`. Thin wrapper over the
- *  shared builder in core/runtime/bearings.ts (the single source of truth, also
- *  used by the promotion guidance dump). Exported for testing. */
+/** Build the full bearings baseline for a conversation without inherited
+ *  crouter context. Exported for testing. */
 export declare function buildContextIntro(nodeId: string): string;
+/** Build the compact node-scoped update for a fork whose copied branch already
+ *  carries a full crouter baseline. Exported for testing. */
+export declare function buildForkContextIntro(nodeId: string): string;
 /**
  * Renderer for `crtr-context` messages. Collapsed (default) shows a one-line
  * stub; expanded (Ctrl+O) shows the label + full body. Returns a plain object
@@ -79,13 +81,8 @@ export declare function buildContextIntro(nodeId: string): string;
 export declare function renderContextMessage(message: RenderedMessageLike, options: {
     expanded?: boolean;
 }, theme: ThemeLike): ComponentLike;
-/**
- * Register the context-intro preamble on `pi`.
- *
- * Returns immediately (inert) when CRTR_NODE_ID is absent. On `session_start`
- * it injects the <crtr-context> block as the first message of a brand-new chat
- * — but only when the session does not already carry it, so a `--session <id>`
- * relaunch (which restores the conversation) never duplicates the block.
- */
+/** Register the context-intro preamble. Fresh branches receive one full
+ *  baseline, forked crouter branches receive one compact update, and resumes
+ *  whose active branch already carries this node's stamp receive nothing. */
 export declare function registerCanvasContextIntro(pi: PiLike): void;
 export default registerCanvasContextIntro;