@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/__tests__/model-pin-durability.test.js

@@ -20,6 +20,7 @@ import { join } from 'node:path';
 import { buildLaunchSpec, isProviderPinnedModelToken, normalizeModel } from '../runtime/launch.js';
 import { defaultModelLaddersConfig } from '../../types.js';
 import { persistDormantModel } from '../runtime/model-swap.js';
+import { promote } from '../runtime/promote.js';
 import { createNode, getNode } from '../canvas/canvas.js';
 import { closeDb } from '../canvas/db.js';
 const ladders = defaultModelLaddersConfig();
@@ -102,6 +103,19 @@ test('an explicit concrete pin survives a config/lifecycle rebuild whose portabl
 // Direction 2: a deliberately TIER-run (unpinned) node must NOT be wrongly
 // re-pinned when a subsequent rebuild/persist normalizes its override to the
 // concrete cell it happens to share bytes with.
+test('promotion preserves the exact-model contract required to revive a private human-work fork', () => {
+    const exactModel = 'openai-codex/gpt-5.6-sol:max';
+    createNode(node('exact-node', {
+        model_override: exactModel,
+        launch: { extensions: [], env: {}, model: exactModel, modelProviderPinned: true, modelExact: true },
+    }));
+    promote('exact-node');
+    const after = getNode('exact-node');
+    assert.equal(after?.mode, 'orchestrator');
+    assert.equal(after?.launch?.model, exactModel);
+    assert.equal(after?.launch?.modelProviderPinned, true);
+    assert.equal(after?.launch?.modelExact, true, 'promotion must not create a launch recipe that reviveNode rejects');
+});
 test('a deliberately tier-run node is not wrongly re-pinned when a rebuild or persist normalizes its override to the concrete cell', () => {
     // The buildLaunchSpec seam: an explicit `false` carried through a rebuild wins
     // over a concrete override that would otherwise read as pinned.

package/dist/core/__tests__/phase4-review-migration.test.d.ts

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

package/dist/core/__tests__/phase4-review-migration.test.js

@@ -0,0 +1,100 @@
+import { test, before, after } 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 { DatabaseSync } from 'node:sqlite';
+import { closeDb, MIGRATIONS, openDb } from '../canvas/db.js';
+import { canvasDbPath, ensureHome } from '../canvas/paths.js';
+let home;
+const legacyOutboxTable = ['consult', 'outbox'].join('_');
+function userVersion(db) {
+    return db.prepare('PRAGMA user_version').get().user_version;
+}
+function names(db, type) {
+    return new Set(db.prepare('SELECT name FROM sqlite_master WHERE type = ?').all(type)
+        .map((row) => row.name));
+}
+function columns(db, table) {
+    return db.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name);
+}
+function migrateToVersion(db, target) {
+    for (let version = userVersion(db); version < target; version += 1) {
+        MIGRATIONS[version](db);
+        db.exec(`PRAGMA user_version = ${version + 1}`);
+    }
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-phase4-review-migration-'));
+    process.env['CRTR_HOME'] = home;
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+});
+test('v27/v28 review schema, v29 anchor state, and v30 outbox drop migrate fresh and from v28', () => {
+    const db = openDb();
+    assert.equal(userVersion(db), 30);
+    assert.equal(names(db, 'table').has(legacyOutboxTable), false);
+    const tables = names(db, 'table');
+    assert.deepEqual(['reviews', 'review_comments', 'review_comment_events'].every((name) => tables.has(name)), true);
+    assert.deepEqual(columns(db, 'reviews'), [
+        'review_id', 'idempotency_key', 'origin_kind', 'origin_node_id', 'bridge_node_id',
+        'companion_node_id', 'review_dir', 'file', 'origin_session_file', 'origin_session_id',
+        'origin_leaf_id', 'model_spec', 'branch_file', 'baseline_sha256', 'baseline_bytes',
+        'anchor_base_sha256', 'anchor_base_bytes', 'state', 'created', 'captured_at', 'opened_at',
+        'output_path', 'subtitle', 'approved_at', 'approved_sha256', 'changed', 'comments_total',
+        'comments_unresolved', 'result_json', 'canceled_at', 'cancel_reason', 'cancel_actor',
+        'delivery_entry_id', 'delivered_at', 'delivery_error', 'projected_at', 'projection_error',
+    ]);
+    assert.deepEqual(columns(db, 'review_comments'), [
+        'comment_id', 'review_id', 'status', 'revision', 'text', 'anchor_line', 'anchor_end_line',
+        'anchor_col_start', 'anchor_col_end', 'anchor_quote', 'anchor_line_text', 'anchor_doc_hash',
+        'author_kind', 'author_node_id', 'updated_by_kind', 'updated_by_node_id', 'created_at',
+        'updated_at', 'resolved_at', 'deleted_at', 'created_seq', 'anchor_state',
+    ]);
+    assert.deepEqual(columns(db, 'review_comment_events'), [
+        'seq', 'review_id', 'comment_id', 'kind', 'state_change', 'revision_after', 'actor_kind',
+        'actor_node_id', 'at', 'operation_id', 'payload',
+    ]);
+    const indexes = names(db, 'index');
+    for (const index of [
+        'idx_reviews_state', 'idx_reviews_origin', 'idx_reviews_file', 'idx_reviews_bridge',
+        'idx_review_comments_review_line_seq', 'idx_review_comments_review_status',
+        'idx_review_comment_events_review_seq', 'idx_review_comment_events_comment_seq',
+    ]) {
+        assert.equal(indexes.has(index), true, `missing ${index}`);
+    }
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    ensureHome();
+    const raw = new DatabaseSync(canvasDbPath());
+    migrateToVersion(raw, 28);
+    assert.equal(userVersion(raw), 28);
+    raw.prepare(`
+    INSERT INTO review_comments
+      (comment_id, review_id, status, revision, text, anchor_line, anchor_end_line,
+       anchor_line_text, anchor_doc_hash, author_kind, updated_by_kind, created_at,
+       updated_at, created_seq)
+    VALUES ('v28-comment', 'v28-review', 'open', 1, 'existing', 1, 1,
+            'source', 'hash', 'human', 'human', '2026-01-01T00:00:00.000Z',
+            '2026-01-01T00:00:00.000Z', 1)
+  `).run();
+    migrateToVersion(raw, 29);
+    assert.equal(userVersion(raw), 29);
+    raw.prepare(`
+    INSERT INTO ${legacyOutboxTable}
+      (node_id, ticket_node_id, request_id, work_kind, status, updated_at)
+    VALUES ('legacy-outbox-node', 'legacy-ticket-node', 'legacy-request', 'follow_up', 'pending', '2026-01-01T00:00:00.000Z')
+  `).run();
+    raw.close();
+    const migrated = openDb();
+    assert.equal(userVersion(migrated), 30);
+    assert.equal(names(migrated, 'table').has('reviews'), true);
+    assert.equal(names(migrated, 'table').has('review_comments'), true);
+    assert.equal(names(migrated, 'table').has('review_comment_events'), true);
+    assert.equal(migrated.prepare("SELECT anchor_state FROM review_comments WHERE comment_id = 'v28-comment'").get().anchor_state, 'live');
+    assert.throws(() => migrated.prepare("UPDATE review_comments SET anchor_state = 'invalid' WHERE comment_id = 'v28-comment'").run());
+    assert.equal(names(migrated, 'table').has(legacyOutboxTable), false);
+});

package/dist/core/__tests__/phase4-review-store.test.d.ts

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

package/dist/core/__tests__/phase4-review-store.test.js

@@ -0,0 +1,143 @@
+import { test, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb, openDb } from '../canvas/db.js';
+import { approveReviewLocked, bindBridgeNode, cancelReviewRow, commitBindingReview, getReview, getReviewByBridge, getReviewByCompanion, listReviews, markDelivered, markDeliveryError, markProjected, markProjectionError, openReviewRow, readAnchorBase, } from '../review/store.js';
+let home;
+function row(overrides = {}) {
+    return {
+        review_id: 'review-one',
+        idempotency_key: 'request-one',
+        origin_kind: 'inline',
+        origin_node_id: 'origin-one',
+        bridge_node_id: null,
+        companion_node_id: 'companion-one',
+        review_dir: '/tmp/review-one',
+        file: '/tmp/does-not-exist.txt',
+        origin_session_file: '/tmp/origin.jsonl',
+        origin_session_id: 'session-one',
+        origin_leaf_id: 'leaf-one',
+        model_spec: 'anthropic/claude:test',
+        branch_file: '/tmp/review-one/branch-point.jsonl',
+        baseline_sha256: 'baseline-hash',
+        baseline_bytes: 3,
+        anchor_base_sha256: 'anchor-hash',
+        anchor_base_bytes: Buffer.from('abc'),
+        state: 'binding',
+        created: '2026-01-01T00:00:00.000Z',
+        captured_at: '2026-01-01T00:00:00.000Z',
+        opened_at: null,
+        output_path: null,
+        subtitle: null,
+        approved_at: null,
+        approved_sha256: null,
+        changed: null,
+        comments_total: null,
+        comments_unresolved: null,
+        result_json: null,
+        canceled_at: null,
+        cancel_reason: null,
+        cancel_actor: null,
+        delivery_entry_id: null,
+        delivered_at: null,
+        delivery_error: null,
+        projected_at: null,
+        projection_error: null,
+        ...overrides,
+    };
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-phase4-review-store-'));
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+});
+test('reviews DAO owns idempotent binding and conditional lifecycle writes', () => {
+    const first = row();
+    assert.equal(existsSync(first.review_dir), false, 'the birth commit does not create filesystem state');
+    assert.deepEqual(commitBindingReview(first), { review_id: 'review-one', won: true });
+    assert.deepEqual(commitBindingReview(row({ review_id: 'review-two', companion_node_id: 'companion-two' })), {
+        review_id: 'review-one',
+        won: false,
+    });
+    assert.equal(listReviews({}).length, 0, 'binding rows are hidden from ordinary review lists');
+    assert.equal(getReview(first.review_id)?.source_missing, true, 'source_missing is computed from the current filesystem');
+    assert.equal(getReviewByCompanion(first.companion_node_id), null);
+    assert.equal(bindBridgeNode(first.review_id, 'bridge-one'), true);
+    assert.equal(bindBridgeNode(first.review_id, 'bridge-two'), false);
+    assert.equal(getReviewByBridge('bridge-one'), null, 'binding rows are not exposed by bridge lookup');
+    assert.equal(openReviewRow(first.review_id, '2026-01-01T00:01:00.000Z'), true);
+    assert.equal(openReviewRow(first.review_id, '2026-01-01T00:02:00.000Z'), false);
+    assert.equal(getReviewByBridge('bridge-one')?.review_id, first.review_id);
+    const db = openDb();
+    assert.equal(approveReviewLocked(db, {
+        review_id: first.review_id,
+        approved_at: '2026-01-01T00:03:00.000Z',
+        approved_sha256: 'approved-hash',
+        changed: true,
+        comments_total: 2,
+        comments_unresolved: 1,
+        result_json: '{"approved":true}',
+    }), true);
+    assert.equal(approveReviewLocked(db, {
+        review_id: first.review_id,
+        approved_at: '2026-01-01T00:04:00.000Z',
+        approved_sha256: 'approved-hash-2',
+        changed: false,
+        comments_total: 0,
+        comments_unresolved: 0,
+        result_json: '{}',
+    }), false, 'a second approval cannot win the conditional write');
+    markProjectionError(first.review_id, 'temporary projection failure');
+    markProjected(first.review_id, '2026-01-01T00:05:00.000Z');
+    markDeliveryError(first.review_id, 'temporary delivery failure');
+    markDelivered(first.review_id, 'receipt-one', '2026-01-01T00:06:00.000Z');
+    const approved = getReview(first.review_id);
+    assert.equal(approved?.projection_error, null);
+    assert.equal(approved?.delivery_error, null);
+    assert.equal(approved?.delivered_at, '2026-01-01T00:06:00.000Z');
+    assert.deepEqual(readAnchorBase(first.review_id), { bytes: Buffer.from('abc'), sha256: 'anchor-hash' });
+});
+test('stale ledger errors cannot overwrite recorded success', () => {
+    const review = row({ review_id: 'review-ledgers', idempotency_key: 'request-ledgers', companion_node_id: 'companion-ledgers' });
+    commitBindingReview(review);
+    markProjected(review.review_id, '2026-01-01T00:05:00.000Z');
+    markProjectionError(review.review_id, 'stale projection failure');
+    markDelivered(review.review_id, 'receipt-ledgers', '2026-01-01T00:06:00.000Z');
+    markDeliveryError(review.review_id, 'stale delivery failure');
+    const recorded = getReview(review.review_id);
+    assert.equal(recorded?.projected_at, '2026-01-01T00:05:00.000Z');
+    assert.equal(recorded?.projection_error, null);
+    assert.equal(recorded?.delivered_at, '2026-01-01T00:06:00.000Z');
+    assert.equal(recorded?.delivery_error, null);
+});
+test('approval cannot win after cancellation and companion ids remain unique', () => {
+    const canceled = row({ review_id: 'review-canceled', idempotency_key: 'request-canceled', companion_node_id: 'companion-canceled' });
+    commitBindingReview(canceled);
+    assert.equal(openReviewRow(canceled.review_id, '2026-01-01T00:59:00.000Z'), true);
+    assert.equal(cancelReviewRow(canceled.review_id, { at: '2026-01-01T01:00:00.000Z', reason: 'not needed', actor: 'human' }), true);
+    assert.equal(approveReviewLocked(openDb(), {
+        review_id: canceled.review_id,
+        approved_at: '2026-01-01T01:01:00.000Z',
+        approved_sha256: 'hash',
+        changed: false,
+        comments_total: 0,
+        comments_unresolved: 0,
+        result_json: '{}',
+    }), false);
+    assert.throws(() => commitBindingReview(row({
+        review_id: 'review-duplicate-companion',
+        idempotency_key: 'request-duplicate-companion',
+        companion_node_id: 'companion-canceled',
+        state: 'binding',
+    })), /UNIQUE constraint failed: reviews\.companion_node_id/);
+});

package/dist/core/__tests__/remote-canvas-target.test.js

@@ -2,7 +2,7 @@
 // `remoteCanvas.targets.<name>` (`../config.ts`'s normalizeRemoteCanvasTarget,
 // exercised through the public readConfig/updateConfig surface — it isn't
 // exported directly) plus `resolveRemoteCanvasTarget`'s error paths
-// (`../view/remote-canvas-target.ts`). The one load-bearing invariant here:
+// (`../remote-canvas-target.ts`). The one load-bearing invariant here:
 // an error message about a missing/unknown target must never leak a token
 // substring, even though it's guiding the agent toward the exact command
 // that would set one.
@@ -13,7 +13,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { readConfig, updateConfig } from '../config.js';
 import { setRelayToken } from '../secrets.js';
-import { getRemoteCanvasTarget, resolveRemoteCanvasTarget } from '../view/remote-canvas-target.js';
+import { getRemoteCanvasTarget, resolveRemoteCanvasTarget } from '../remote-canvas-target.js';
 let home;
 let realHome;
 before(() => {

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

@@ -33,16 +33,15 @@ import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn, spawnSync } from 'node:child_process';
-import { createNode, getNode, subscribe, updateNode, clearPid } from '../canvas/canvas.js';
-import { armFollowUpWork } from '../canvas/human-work-outbox.js';
+import { createNode, getNode, subscribe, updateNode } from '../canvas/canvas.js';
 import { armCron, hasPendingCancelOnWakeCron } from '../canvas/crons.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { closeDb } from '../canvas/db.js';
 import { buildPiArgv, CANVAS_EXTENSIONS } from '../runtime/launch.js';
-import { CANVAS_INBOX_WATCHER_PATH } from '../runtime/canvas-extensions.js';
+import { CANVAS_CONTEXT_INTRO_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_REVIEW_BOUNDARY_PATH, CANVAS_STOPHOOK_PATH, } from '../runtime/canvas-extensions.js';
 import { headlessBrokerHost } from '../runtime/host.js';
 import { resumeArgs, reviveNode } from '../runtime/revive.js';
-import { REVIVE_KICKOFF_SENTINEL, writeGoal } from '../runtime/kickoff.js';
+import { REVIVE_KICKOFF_SENTINEL, readGoal, writeGoal } from '../runtime/kickoff.js';
 import { seedRoadmap } from '../runtime/roadmap.js';
 import { InputError } from '../io.js';
 import { createHarness } from './helpers/harness.js';
@@ -193,6 +192,8 @@ test('buildPiArgv restores mandatory canvas extensions when persisted launch met
         assert.equal(seen.get(ext), 1, `mandatory extension present exactly once: ${ext}`);
     }
     assert.deepEqual(extensions.slice(0, required.size), mandatory, 'mandatory extensions are loaded first and once');
+    assert.equal(extensions.indexOf(CANVAS_STOPHOOK_PATH), extensions.indexOf(CANVAS_REVIEW_BOUNDARY_PATH) + 1, 'review boundary runs immediately before the stophook commits a companion bind');
+    assert.ok(extensions.indexOf(CANVAS_CONTEXT_INTRO_PATH) > extensions.indexOf(CANVAS_REVIEW_BOUNDARY_PATH), 'review boundary still precedes fork bearings');
 });
 test('buildPiArgv replaces the previous mandatory prefix with the current canvas hooks', () => {
     const historicalNames = [
@@ -424,66 +425,34 @@ test('reviveNode fresh-fallback clears the stale session identity (Major-3: no p
         await h.dispose();
     }
 });
-test('private fork revival uses immutable provenance once, then only its bound child session', () => {
+test('an unbound ordinary fork replays its immutable source with and without its goal', () => {
     const originalLaunch = headlessBrokerHost.launch;
-    // No harness here — bind a standalone in-process fleet so reviveNode's
-    // boundFleet() resolves; the launch stub below registers with it exactly as
-    // the real host does (registration is the launch seam's contract).
     const tf = bindTestFleet();
-    const privateId = 'private-fork';
-    const forkFile = join(home, 'private-source.jsonl');
-    const childFile = join(home, 'private-child.jsonl');
-    const exactModel = 'openai-codex/gpt-5.3-codex:xhigh';
-    const kickoff = 'private immutable kickoff';
+    const forkFile = join(home, 'ordinary-fork-source.jsonl');
     const launches = [];
     try {
         mkdirSync(home, { recursive: true });
         writeFileSync(forkFile, '{}\n', 'utf8');
-        createNode(node(privateId, {
-            kind: 'general',
-            cwd: home,
-            fork_from: forkFile,
-            human_work_target: { work_kind: 'follow_up', dir: '/ticket', request_id: 'request-1', root: '/root' },
-            private_fork_phase: 'fork_pending',
-            private_fork_recipe: { kickoff },
-            launch: { model: exactModel, modelExact: true, tools: [], extensions: [], env: {} },
-        }));
-        // reviveNode's locked launch-gate (Major-3) requires a still-armed matching
-        // human-work row before it will launch a private fork — arm one here to
-        // mirror the real handleFollowUpStart/handleVisualStart claim it recheck.
-        armFollowUpWork({ nodeId: privateId, dir: '/ticket', root: '/root', requestId: 'request-1' });
         headlessBrokerHost.launch = (nodeId, inv) => {
-            launches.push({ argv: [...inv.argv], env: { ...inv.env } });
+            launches.push([...inv.argv]);
             const handle = { pid: disposableLivePid(), exited: new Promise(() => { }) };
-            // Mirror the real host contract: the entry IS liveness (design D-1).
             tf.fleet.register(nodeId, handle);
             return handle;
         };
-        reviveNode(privateId, { resume: false });
-        const pending = launches[0];
-        const forkIndex = pending.argv.indexOf('--fork');
-        assert.equal(pending.argv[forkIndex + 1], forkFile, 'pending claim forks exactly from immutable provenance');
-        assert.equal(pending.argv.at(-1), kickoff, 'pending claim uses its persisted kickoff');
-        assert.equal(pending.argv[pending.argv.indexOf('--model') + 1], exactModel, 'pending claim preserves its exact model');
-        reviveNode(privateId, { resume: false });
-        assert.equal(launches.length, 1, 'live first launch (a live fleet entry) makes a concurrent revive a no-op');
-        writeFileSync(childFile, '{}\n', 'utf8');
-        // Model the first broker's death: its exit removes the fleet entry (and the
-        // stophook clears the recorded pid) — the next revive may proceed.
-        tf.fleet.forget(privateId);
-        clearPid(privateId);
-        updateNode(privateId, {
-            pi_session_id: 'child-session',
-            pi_session_file: childFile,
-            private_fork_phase: 'session_started',
-        });
-        reviveNode(privateId, { resume: false });
-        const started = launches[1];
-        const sessionIndex = started.argv.indexOf('--session');
-        assert.equal(started.argv[sessionIndex + 1], childFile, 'bound claim resumes only its writable child session');
-        assert.equal(started.argv.includes('--fork'), false, 'bound claim never forks provenance again');
-        assert.equal(started.argv.includes(kickoff), false, 'bound claim never replays its one-shot kickoff');
-        assert.equal(started.argv.includes('--crtr-new-cycle'), false, 'bound claim ignores a no-resume request rather than cycling');
+        createNode(node('ordinary-fork-promptless', { cwd: home, fork_from: forkFile }));
+        reviveNode('ordinary-fork-promptless', { resume: true });
+        const promptless = launches[0];
+        const promptlessFork = promptless.indexOf('--fork');
+        assert.equal(promptless[promptlessFork + 1], forkFile, 'an unbound ordinary fork uses its immutable source');
+        assert.deepEqual(promptless, buildPiArgv(getNode('ordinary-fork-promptless'), { forkFrom: forkFile }).argv, 'a promptless fork has no trailing positional prompt');
+        createNode(node('ordinary-fork-goal', { cwd: home, fork_from: forkFile }));
+        writeGoal('ordinary-fork-goal', 'continue the forked task');
+        const goal = readGoal('ordinary-fork-goal');
+        reviveNode('ordinary-fork-goal', { resume: false });
+        const goalCarrying = launches[1];
+        const goalFork = goalCarrying.indexOf('--fork');
+        assert.equal(goalCarrying[goalFork + 1], forkFile, 'an unbound ordinary fork uses its immutable source regardless of requested resume mode');
+        assert.equal(goalCarrying.at(-1), goal, 'a goal-carrying fork preserves its exact goal as the trailing prompt');
     }
     finally {
         headlessBrokerHost.launch = originalLaunch;

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

@@ -19,6 +19,32 @@ function userMsg(id, parentId, text) {
         message: { role: 'user', content: text, timestamp: 0 },
     };
 }
+function assistantMsg(id, parentId, content, stopReason, errorMessage) {
+    return {
+        type: 'message',
+        id,
+        parentId,
+        timestamp: new Date(0).toISOString(),
+        message: { role: 'assistant', content, stopReason, errorMessage, timestamp: 0 },
+    };
+}
+function cycleManager(entries, currentId) {
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const branchFrom = (fromId) => {
+        const path = [];
+        let current = byId.get(fromId);
+        while (current) {
+            path.push(current);
+            current = current.parentId ? byId.get(current.parentId) : undefined;
+        }
+        return path.reverse();
+    };
+    return {
+        buildSessionContext: () => buildSessionContext(entries, currentId, byId),
+        getEntries: () => entries,
+        getBranch: (fromId) => branchFrom(fromId ?? currentId),
+    };
+}
 test('cycleAwareMessages: a compacted prior cycle replays via buildSessionContext (one summary, no raw pre-compaction messages)', () => {
     // Cycle 0: m1 -> m2 -> [compaction c1, keeping from m2] -> m3 (cycle 0's leaf
     // at yield time). Cycle marker cy1 roots a FRESH branch (parentId: null, per
@@ -46,25 +72,9 @@ test('cycleAwareMessages: a compacted prior cycle replays via buildSessionContex
     };
     const m4 = userMsg('m4', 'cy1', 'cycle 1 live message');
     const entries = [m1, m2, c1, m3, cy1, m4];
-    const byId = new Map(entries.map((e) => [e.id, e]));
-    function branchFrom(fromId) {
-        const path = [];
-        let current = fromId ? byId.get(fromId) : undefined;
-        while (current) {
-            path.push(current);
-            current = current.parentId ? byId.get(current.parentId) : undefined;
-        }
-        return path.reverse();
-    }
     // Minimal fake mirroring the real SDK's SessionManager just enough to drive
-    // cycleAwareMessages: buildSessionContext() (current leaf only, m4) plus the
-    // tree accessors it reads (getEntries/getBranch).
-    const sm = {
-        buildSessionContext: () => buildSessionContext(entries, 'm4', byId),
-        getEntries: () => entries,
-        getBranch: (fromId) => branchFrom(fromId ?? 'm4'),
-    };
-    const out = cycleAwareMessages(sm);
+    // cycleAwareMessages: buildSessionContext() plus the tree accessors it reads.
+    const out = cycleAwareMessages(cycleManager(entries, 'm4'));
     const summaries = out.filter((m) => m.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 : ''));
@@ -75,3 +85,23 @@ test('cycleAwareMessages: a compacted prior cycle replays via buildSessionContex
     const dividers = out.filter((m) => m.customType === 'crtr-cycle-divider');
     assert.equal(dividers.length, 1, 'one divider between the replayed prior cycle and the live one');
 });
+test('cycleAwareMessages: a yielded cycle keeps terminal assistant content without an abort notice', () => {
+    const m1 = userMsg('m1', null, 'yield after this turn');
+    const toolCall = { type: 'toolCall', id: 'yield-call', name: 'bash', arguments: { command: 'crtr node yield' } };
+    const m2 = assistantMsg('m2', 'm1', [toolCall], 'aborted', 'Request was aborted');
+    const cy1 = {
+        type: 'custom',
+        id: 'cy1',
+        parentId: null,
+        timestamp: new Date(1).toISOString(),
+        customType: CRTR_CYCLE_CUSTOM_TYPE,
+        data: { cycle: 2, fromLeaf: 'm2' },
+    };
+    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.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);
+});

package/dist/core/__tests__/spawn-no-kickoff.test.js

@@ -1,8 +1,7 @@
 // spawnChild({ prompt: '' }) — the no-kickoff path `node new --root --no-kickoff`
-// rides. Proves the mechanism the guest convo-node birth now relies on: an empty
-// prompt reaches buildPiArgv as `undefined`-equivalent (no positional pushed), so
-// the broker never drives a kickoff turn — the node comes up idle, goal-less, and
-// (when forking) without an identity-reassertion turn either.
+// rides. An empty prompt reaches buildPiArgv as `undefined`-equivalent, so the
+// broker comes up idle and goal-less. Fork identity is carried by the canonical
+// session-start bearings message rather than by either kickoff shape.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
@@ -82,7 +81,7 @@ test('no-kickoff root: no positional prompt reaches pi argv, and no goal is pers
         rmSync(cwdWithKickoff, { recursive: true, force: true });
     }
 });
-test('no-kickoff + fork-from: the forked history rides through with NO identity-reassertion/kickoff turn', async () => {
+test('fork-from keeps identity out of the task prompt with or without kickoff', async () => {
     const cwdNoKickoff = mkdtempSync(join(tmpdir(), 'crtr-no-kickoff-fork-cwd-'));
     const cwdWithKickoff = mkdtempSync(join(tmpdir(), 'crtr-kickoff-fork-cwd-'));
     const seedPathNoKickoff = join(cwdNoKickoff, 'seed.jsonl');
@@ -101,14 +100,11 @@ test('no-kickoff + fork-from: the forked history rides through with NO identity-
         assert.ok(argvNoKickoff.includes(seedPathNoKickoff), 'the resolved seed path is the no-kickoff fork source');
         assert.ok(argvWithKickoff.includes('--fork'), 'the real-kickoff fork source still rides through to pi');
         assert.ok(argvWithKickoff.includes(seedPathWithKickoff), 'the resolved seed path is the real-kickoff fork source');
-        // The real-kickoff fork prepends an identity re-assertion ("you are a FORK
-        // of ...") to its kickoff prompt (existing behavior, unchanged) — the
-        // no-kickoff fork gets neither that block nor any prompt at all, since no
-        // turn ever runs at spawn to carry it.
+        // A real kickoff carries exactly the user's task. The session-start
+        // bearings message owns fork identity for both prompt shapes.
         const trailingWithKickoff = argvWithKickoff[argvWithKickoff.length - 1];
-        assert.match(trailingWithKickoff, /a FORK of/, 'the identity re-assertion still leads a real fork kickoff');
-        assert.match(trailingWithKickoff, /continue please$/, 'the real prompt still trails the identity block');
-        assert.notEqual(argvNoKickoff[argvNoKickoff.length - 1], trailingWithKickoff, 'the no-kickoff fork carries no identity/kickoff turn at all');
+        assert.equal(trailingWithKickoff, 'continue please', 'the real fork kickoff is the unmodified user task');
+        assert.notEqual(argvNoKickoff[argvNoKickoff.length - 1], trailingWithKickoff, 'the no-kickoff fork carries no task prompt');
     }
     finally {
         cap.restore();

package/dist/core/__tests__/stop-guard.test.js

@@ -5,11 +5,13 @@
 // final, so it may go dormant regardless of whether it has a parent.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, deliverAndSettleMessageWait, getNode, subscribe, setMessageWait, setStatus } from '../canvas/canvas.js';
 import { closeDb, openDb } from '../canvas/db.js';
+import { contextDir } from '../canvas/paths.js';
+import { bashJobPaths } from '../bash-jobs.js';
 import { evaluateStop } from '../runtime/stop-guard.js';
 import { writeOutputSchema } from '../runtime/structured-output.js';
 let home;
@@ -67,6 +69,19 @@ test('a TERMINAL node with nothing live to await and no final pushed is reprompt
     assert.equal(d.action, 'reprompt');
     assert.equal(d.reason, 'stalled');
 });
+test('a TERMINAL node awaiting a background bash job may dorm until its completion message', () => {
+    createNode(node('bashWait', { parent: 'mgr', lifecycle: 'terminal' }));
+    const paths = bashJobPaths(contextDir('bashWait'), `${Date.now()}-fixture`);
+    mkdirSync(paths.dir, { recursive: true });
+    writeFileSync(paths.cmdSh, 'long-running command');
+    writeFileSync(paths.jobLog, '');
+    writeFileSync(paths.jobBg, '');
+    assert.deepEqual(evaluateStop('bashWait', noSignals), { action: 'allow', reason: 'awaiting' });
+    writeFileSync(paths.jobExit, '0');
+    const completed = evaluateStop('bashWait', noSignals);
+    assert.equal(completed.action, 'reprompt');
+    assert.equal(completed.reason, 'stalled');
+});
 test('only an explicit live controller wait permits dormancy; ancestry alone does not', () => {
     createNode(node('parent', { lifecycle: 'terminal', status: 'active' }));
     createNode(node('child', { parent: 'parent' }));