@north-light/crouter 0.3.172 → 0.3.174

package/dist/core/__tests__/context-intro.test.js

@@ -1,33 +1,46 @@
 // Tests for the <crtr-bearings> preamble:
-//   1. Worker and orchestrator bearings carry the `<memory kind="knowledge">`
-//      block (substrate knowledge docs + node-local docs as a file tree).
-//      Orchestrators add the across-cycles framing; promotion delivers that
-//      same orchestrator context-dir framing to a node that spawned base.
+//   1. Situational context rides the bearings as a sibling block, and only
+//      once something has been set.
 //   2. canvas-context-intro injects the block as its own session message at
-//      session_start (before the first prompt), idempotent across resumes.
+//      session_start (before the first prompt), idempotent across resumes,
+//      inert without a node id — and its renderer never overruns the terminal.
 //
 // Run: node --import tsx/esm --test src/core/__tests__/context-intro.test.ts
-import { test, before, beforeEach, after } from 'node:test';
+import { test, before, beforeEach, after, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { closeDb } from '../canvas/db.js';
-import { contextDir } from '../canvas/paths.js';
+import { apiSocketPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
-import { promote } from '../runtime/promote.js';
-import { personaDrift } from '../runtime/persona.js';
-import { memoryDir } from '../runtime/memory.js';
 import { appendSituationalContext, situationalContextBlock } from '../runtime/situational-context.js';
-import registerCanvasContextIntro, { buildContextIntro, renderContextMessage, CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
+import registerCanvasContextIntro, { renderContextMessage, CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
+import { buildContextBearings as buildContextIntro } from '../runtime/bearings.js';
+import { createApiServer } from '../../daemon/api/server.js';
 let home;
+let server;
+async function waitForSocket(path) {
+    for (let i = 0; i < 200; i++) {
+        if (existsSync(path))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error(`api socket never bound at ${path}`);
+}
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-ctxintro-'));
     process.env['CRTR_HOME'] = home;
 });
-beforeEach(() => {
+beforeEach(async () => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+    server = createApiServer();
+    await waitForSocket(apiSocketPath());
+});
+afterEach(async () => {
+    await server.close();
 });
 after(() => {
     closeDb();
@@ -35,42 +48,6 @@ after(() => {
     delete process.env['CRTR_HOME'];
     delete process.env['CRTR_NODE_ID'];
 });
-test('worker bearings: base framing + <knowledge> block, NO across-cycles framing', () => {
-    // Bug-regression: review finding M1 — buildContextBearings renders the
-    // <knowledge> block (renderKnowledgeBlock): a kind-wrapped file tree of
-    // knowledge docs. This test locks in that contract.
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    // Seed a node-local substrate doc so the knowledge block is non-empty.
-    const dir = memoryDir(meta.node_id);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'test-ref.md'), '---\nkind: knowledge\nwhen-and-why-to-read: When testing, this reference should be read because it is a regression fixture\nsystem-prompt-visibility: preview\n---\nTest body.\n');
-    const block = buildContextIntro(meta.node_id);
-    assert.match(block, /<crtr-bearings>/, 'opens with the bearings section');
-    assert.ok(block.includes(contextDir(meta.node_id)), 'names the context-dir path inline (no dir= attribute)');
-    assert.doesNotMatch(block, /<crtr-context/, 'no legacy <crtr-context dir=…> wrapper');
-    assert.match(block, /## Your context directory/, 'context dir is its own markdown subsection');
-    assert.match(block, /shared document store, not a task tracker/, 'base = shared docs, not tasks');
-    // The catalog is a sibling <memory kind="knowledge"> block, never nested
-    // under anything dir-scoped.
-    assert.match(block, /<memory kind="knowledge">/, 'knowledge catalog present as a memory block');
-    // Per-store stanza headers (label · dir) never appear.
-    assert.doesNotMatch(block, /user-global · /, 'no user-global label·dir stanza');
-    assert.doesNotMatch(block, /node-local · /, 'no node-local label·dir stanza');
-    // No (empty) placeholder marker.
-    assert.doesNotMatch(block, /\(empty\)/, 'no (empty) placeholder');
-    assert.match(block, /\nknowledge\n/, 'tree headed by the `knowledge` root label');
-    // The node-local preview-rung doc renders as a tree entry with a `# read when:`
-    // routing line (verbatim previewLine output).
-    assert.match(block, /test-ref {2}# read when: When testing, this reference should be read because it is a regression fixture\./, 'node-local preview doc renders its routing line');
-    assert.match(block, /<project_context>/, 'project_context now rides the bearings even without project files');
-    assert.match(block, /<environment cwd="\/tmp\/work">/, 'environment block is always present');
-    assert.match(block, /Host: .+ \u00b7 tmux server: (reachable|none)/, 'environment block reports a host/runtime line with tmux server reachability');
-    assert.match(block, /Directory listing: unavailable \(cwd missing or unreadable\)\./, 'missing cwd degrades the directory listing');
-    assert.match(block, /Git: not a git repository\./, 'missing cwd degrades git info');
-    // A terminal worker must NOT carry the orchestrator across-cycles framing.
-    assert.doesNotMatch(block, /refresh cycles/, 'no across-cycles framing for a terminal worker');
-    assert.match(block, /<\/crtr-bearings>/);
-});
 test('situational context rides the bearings as a sibling <situational-context> block; empty when unset', () => {
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     assert.equal(situationalContextBlock(meta.node_id), '', 'no block until something is set');
@@ -81,94 +58,6 @@ test('situational context rides the bearings as a sibling <situational-context>
     assert.match(block, /user is looking at the billing applet/, 'block carries the ambient text');
     assert.ok(!/<situational-context>[\s\S]*<\/crtr-bearings>/.test(block), 'the block is a sibling of <crtr-bearings>, not nested inside it');
 });
-test('node-local doc identity honors explicit frontmatter `name`, not the physical filename', () => {
-    // node-local docs follow the one substrate identity rule (resolveDocName):
-    // an explicit `name:` renders and dedups under that name, not the filename.
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    const dir = memoryDir(meta.node_id);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'physical-filename.md'), '---\nkind: knowledge\nname: explicit-identity\nwhen-and-why-to-read: When testing, this reference should be read because it is a regression fixture\nsystem-prompt-visibility: preview\n---\nTest body.\n');
-    const block = buildContextIntro(meta.node_id);
-    assert.match(block, /\u2500 explicit-identity {2}# read when:/, 'tree entry renders under the explicit frontmatter name');
-    assert.ok(!block.includes('physical-filename'), 'the physical filename never surfaces once an explicit name is set');
-});
-test('a CLAUDE.md in the node\'s cwd does not enter the bearings; only the <environment> snapshot remains', () => {
-    // buildProjectContextBlock now emits only the cwd/git environment snapshot.
-    // Project guidance lives in the document substrate instead, so a bare on-disk
-    // CLAUDE.md stays out of the bearings entirely.
-    const proj = mkdtempSync(join(tmpdir(), 'crtr-proj-'));
-    writeFileSync(join(proj, 'CLAUDE.md'), 'PROJECT_MARKER: build then commit.\n');
-    const meta = spawnNode({ kind: 'general', cwd: proj, parent: null });
-    const block = buildContextIntro(meta.node_id);
-    assert.doesNotMatch(block, /<project_instructions/, 'no <project_instructions> block is ever emitted');
-    assert.doesNotMatch(block, /PROJECT_MARKER: build then commit\./, 'the CLAUDE.md body never rides the bearings');
-    assert.match(block, /<project_context>/, 'project_context wrapper still present');
-    assert.match(block, /<environment cwd=".*crtr-proj-.*">/, 'environment block still rides inside project_context');
-    assert.match(block, /Directory:\n  CLAUDE\.md\n/, 'environment block still includes an ls-style listing');
-    assert.match(block, /Git: not a git repository\./, 'git snapshot degrades cleanly for a non-repo');
-    assert.match(block, /<environment[\s\S]*<\/environment>\n<\/project_context>$/, 'environment block closes project_context');
-    assert.ok(block.indexOf('</crtr-bearings>') < block.indexOf('<project_context>'), 'project_context follows the crtr-bearings block');
-    rmSync(proj, { recursive: true, force: true });
-});
-test('orchestrator bearings: across-cycles framing + node-local substrate docs ride into <knowledge>; a non-substrate .md file is never inlined', () => {
-    // Bug-regression: review finding M1 — buildContextBearings renders <knowledge>.
-    // Node-local substrate docs render as tree entries at their rung; a
-    // non-substrate .md file (no frontmatter `kind`) never surfaces.
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    promote(meta.node_id); // flip to orchestrator mode — the across-cycles gate
-    const dir = memoryDir(meta.node_id);
-    mkdirSync(dir, { recursive: true });
-    // Write a non-substrate MEMORY.md file to verify it is never surfaced in the block.
-    const legacyIndexPath = join(dir, 'MEMORY.md');
-    writeFileSync(legacyIndexPath, '# memory index — one pointer line per memory; how-to in "Your long-term memory".\n\n- [Flaky build](flaky-build.md) — first run fails\n');
-    // A node-local substrate doc DOES ride into the knowledge block at its rung.
-    writeFileSync(join(dir, 'flaky-build.md'), '---\nkind: knowledge\nwhen-and-why-to-read: When the build flakes, this reference should be read because the first run fails\nsystem-prompt-visibility: preview\n---\nFirst run always fails; rerun once.\n');
-    const block = buildContextIntro(meta.node_id);
-    assert.match(block, /shared document store, not a task tracker/, 'still carries the base framing');
-    assert.match(block, /refresh cycles/, 'orchestrator gets the across-cycles framing');
-    assert.match(block, /<memory kind="knowledge">/, 'knowledge catalog present as a memory block');
-    assert.match(block, /flaky-build {2}# read when: When the build flakes, this reference should be read because the first run fails\./, 'node-local doc renders as a tree entry with its routing line');
-    // The non-substrate file never renders: no header line, no pointer line, no path.
-    assert.ok(!block.includes('# memory index'), 'the index header comment is NOT inlined');
-    assert.ok(!block.includes('- [Flaky build](flaky-build.md)'), 'index pointer lines are NOT inlined');
-    assert.ok(!block.includes(legacyIndexPath), 'no absolute index (MEMORY.md) path');
-    assert.ok(!block.includes('node-local · '), 'no label·dir stanza header');
-    assert.match(block, /<\/crtr-bearings>/);
-});
-test('orchestrator bearings: no per-store stanzas or (empty) markers; a rung-none node-local doc still surfaces as a bare-name tree entry', () => {
-    // Bug-regression: review findings M1 + M6 — the <knowledge> block carries no
-    // per-store `label · dir` stanzas or (empty) markers, and node-local docs are
-    // NOT filtered on rung: a migrated node-local doc defaults
-    // system-prompt-visibility: none and must still ride into the knowledge memory block as
-    // its bare name (floored to the `name` rung; never its body).
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    promote(meta.node_id); // flip to orchestrator mode
-    const dir = memoryDir(meta.node_id);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'rung-none-fact.md'), '---\nkind: knowledge\n---\nbody that must not render at the none rung\n');
-    const block = buildContextIntro(meta.node_id);
-    // No per-store stanza headers, no (empty) markers, no MEMORY.md paths.
-    assert.ok(!block.includes(`node-local · ${memoryDir(meta.node_id)}`), 'no node-local stanza header');
-    assert.ok(!block.includes('user-global · '), 'no user-global stanza header');
-    assert.ok(!block.includes('project · '), 'no project stanza header');
-    assert.doesNotMatch(block, /\(empty\)/, 'no (empty) markers');
-    assert.ok(!block.includes('MEMORY.md'), 'no MEMORY.md path in the block');
-    // M6: rung-none node-local doc surfaces as a bare-name tree entry only.
-    assert.match(block, /─ rung-none-fact\n/, 'rung-none node-local doc surfaces as a bare-name tree entry');
-    assert.ok(!block.includes('body that must not render'), 'none rung renders the name only, not the body');
-});
-test('promotion guidance delivers the orchestrator context-dir framing', () => {
-    // A node spawns as a base worker (no orchestrator bearings). On promotion the
-    // persona injector must build the across-cycles context-dir framing it never
-    // got at spawn (delivered at the next turn boundary, not returned by promote).
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    promote(meta.node_id);
-    const drift = personaDrift(meta.node_id);
-    const guidance = drift?.guidance ?? '';
-    assert.ok(drift !== null, 'promotion drifts the persona (base→orchestrator)');
-    assert.match(guidance, /refresh cycles/, 'promotion guidance carries the across-cycles framing');
-    assert.ok(guidance.includes(contextDir(meta.node_id)), 'and names the context dir path');
-});
 function makeFakePi() {
     return {
         sent: [],
@@ -182,7 +71,7 @@ function makeFakePi() {
 function fakeCtx(entries = []) {
     return { sessionManager: { getEntries: () => entries } };
 }
-test('session_start injects the block as the first message of an empty session', () => {
+test('session_start injects the block as the first message of an empty session', async () => {
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     const pi = makeFakePi();
@@ -190,13 +79,13 @@ test('session_start injects the block as the first message of an empty session',
     assert.ok(pi.handler, 'session_start handler registered');
     // Empty session → inject the block as its own custom message (no delivery
     // options → it precedes the first prompt).
-    pi.handler({ reason: 'startup' }, fakeCtx());
+    await pi.handler({ reason: 'startup' }, fakeCtx());
     assert.equal(pi.sent.length, 1, 'one message injected');
     assert.equal(pi.sent[0].customType, CONTEXT_INTRO_CUSTOM_TYPE);
     assert.equal(pi.sent[0].display, true);
     assert.match(pi.sent[0].content, /<crtr-bearings>/);
 });
-test('session_start is idempotent across resume (skips if already in history)', () => {
+test('session_start is idempotent across resume (skips if already in history)', async () => {
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     // Restored session already carries OUR block (which names this node id) → no
@@ -209,14 +98,14 @@ test('session_start is idempotent across resume (skips if already in history)',
     const entries = [
         { type: 'custom_message', customType: CONTEXT_INTRO_CUSTOM_TYPE, content: buildContextIntro(meta.node_id) },
     ];
-    pi.handler({ reason: 'resume' }, fakeCtx(entries));
+    await pi.handler({ reason: 'resume' }, fakeCtx(entries));
     assert.equal(pi.sent.length, 0, 'our own block already in history → skip');
 });
-test('session_start is inert when CRTR_NODE_ID is absent', () => {
+test('session_start is inert when CRTR_NODE_ID is absent', async () => {
     delete process.env['CRTR_NODE_ID'];
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
-    pi.handler({ reason: 'startup' }, fakeCtx());
+    await pi.handler({ reason: 'startup' }, fakeCtx());
     assert.equal(pi.sent.length, 0);
 });
 test('renderer registered for the customType; collapsed hides body, ctrl+o expand reveals it', () => {

package/dist/core/__tests__/cron-broker-capacity.test.js

@@ -9,12 +9,13 @@
 // no broker capacity and is never gated.
 import { after, afterEach, before, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
 import { closeDb } from '../canvas/db.js';
-import { armCron, getCron, listCronRuns } from '../canvas/crons.js';
-import { cronLaunchesNode, runDueCrons } from '../../daemon/cron-run.js';
+import { armCron, cancelCron, getCron, listCronRuns } from '../canvas/crons.js';
+import { cronLaunchesNode, executeCron, markSelfCanceledCronRun, runDueCrons } from '../../daemon/cron-run.js';
 let home;
 let realHome;
 function arm(overrides) {
@@ -87,6 +88,24 @@ test('a plain shell cron runs at zero capacity — only launches are gated', asy
     await Promise.all(settlements);
     assert.equal(getCron('plain-shell'), null, 'the one-shot settled and was consumed');
 });
+test('an on-change cron that cancels itself still delivers its final output', async () => {
+    const runIdPath = join(home, 'self-cancel-run-id');
+    arm({
+        cron_id: 'self-cancel-delivery',
+        command: `printf '%s' "$CRTR_RUN_ID" > '${runIdPath}'; echo settled; sleep 0.1`,
+        recur: JSON.stringify({ every: '1h' }),
+        on_output: 'on-change',
+        sink: JSON.stringify({ human: true }),
+    });
+    const run = executeCron(getCron('self-cancel-delivery'), { outOfBand: false });
+    for (let i = 0; i < 50 && !existsSync(runIdPath); i++)
+        await delay(10);
+    assert.ok(existsSync(runIdPath), 'the live run exposed its id to its self-cancel command');
+    assert.equal(markSelfCanceledCronRun('self-cancel-delivery', readFileSync(runIdPath, 'utf8')), true);
+    assert.equal(cancelCron('self-cancel-delivery', { preserveRunningProcess: true }), true);
+    const record = await run;
+    assert.equal(record?.delivered, 'delivered: human notify');
+});
 test('cronLaunchesNode classifies by command verb and armed sink', () => {
     const of = (command, sink = '{}') => cronLaunchesNode({ command, sink });
     assert.equal(of("crtr node lifecycle revive 'n' --fresh"), true);

package/dist/core/__tests__/daemon-boot.test.js

@@ -8,11 +8,11 @@ import { createServer } from 'node:net';
 import { createNode, getNode, subscribe } from '../canvas/canvas.js';
 import { closeDb } from '../canvas/db.js';
 import { readInboxSince } from '../feed/inbox.js';
-import { superviseTick, readPidfile } from '../../daemon/crtrd.js';
+import { superviseTick } from '../../daemon/crtrd.js';
+import { readPidfile } from '../../daemon/pidfile.js';
 import { verifyDaemonStartup, waitForDaemonExit } from '../../daemon/manage.js';
 import { waitForBrokerViewSocket } from '../runtime/placement-tmux.js';
 import { viewSocketPath } from '../canvas/paths.js';
-import { signBrandedHostArtifacts, brandedHostWorks, codesignIdentitiesForBrandedHost } from '../runtime/branded-host.js';
 import { markBusy, clearBusy } from '../runtime/busy.js';
 import { bindTestFleet } from './helpers/fleet.js';
 import { resetFleetForTests } from '../runtime/fleet.js';
@@ -354,21 +354,3 @@ test('waitForBrokerViewSocket returns false as soon as the real broker process e
     assert.equal(ready, false, 'an exited broker must fail readiness');
     assert.ok(Date.now() - started < 1000, 'the readiness guard must fail fast instead of waiting for the socket deadline');
 });
-test('signBrandedHostArtifacts signs the copied libnode before the branded binary', () => {
-    const signed = [];
-    signBrandedHostArtifacts('/tmp/crouter', '/tmp/libnode.dylib', (path) => signed.push(path));
-    assert.deepEqual(signed, ['/tmp/libnode.dylib', '/tmp/crouter']);
-});
-test('codesignIdentitiesForBrandedHost prefers configured or discovered identities and otherwise ad-hoc signs', () => {
-    assert.deepEqual(codesignIdentitiesForBrandedHost({ configured: 'Developer ID Application: Example', discovered: 'Apple Development: Local' }), ['Developer ID Application: Example']);
-    assert.deepEqual(codesignIdentitiesForBrandedHost({ discovered: 'Apple Development: Local' }), ['Apple Development: Local']);
-    assert.deepEqual(codesignIdentitiesForBrandedHost(), ['-']);
-});
-test('brandedHostWorks health-checks if a binary is executable', () => {
-    // Issue #102: the branded host binary can be corrupted or killed by macOS
-    // before exec, causing spawn() to fail silently. The health-check detects this.
-    const goodBin = process.execPath; // a real, executable binary
-    const badBin = '/nonexistent/crouter-broken';
-    assert.equal(brandedHostWorks(goodBin), true, 'health-check passes for a real executable binary');
-    assert.equal(brandedHostWorks(badBin), false, 'health-check fails for a nonexistent binary');
-});

package/dist/core/__tests__/daemon-wedge.test.js

@@ -12,7 +12,7 @@
 // fires on its own (fails toward 'pending', not 'wedged').
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { wedgeVerdict, WEDGE_QUIET_MS, WEDGE_CPU_MAX_PERCENT, sumTreeCpu, treeHasDescendants } from '../../daemon/crtrd.js';
+import { wedgeVerdict, WEDGE_QUIET_MS, WEDGE_CPU_MAX_PERCENT, sumTreeCpu, treeHasDescendants, } from '../../daemon/reconcilers/broker-supervision.js';
 test('wedgeVerdict: a node whose turn already ended is never wedged, regardless of the other signals', () => {
     assert.equal(wedgeVerdict({ busy: false, quietForMs: null, cpuPercent: null }), 'leave');
     assert.equal(wedgeVerdict({ busy: false, quietForMs: 10 * 60 * 60_000, cpuPercent: 0 }), 'leave');

package/dist/core/__tests__/dead-node-policy-table.test.js

@@ -11,7 +11,7 @@
 // unchanged — only its caller moved into the table).
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { classifyDeadNode, retryResumeMode, respawnBackoffMs, HEALTHY_UPTIME_MS, MAX_RESPAWN_ATTEMPTS, } from '../../daemon/fleet.js';
+import { classifyDeadNode, retryResumeMode } from '../../daemon/fleet.js';
 /** A table-row fixture: an active, booted-or-not node in the named state. */
 function row(over = {}) {
     return {
@@ -83,20 +83,3 @@ test('retryResumeMode: interrupted turns and pending cycles recover as cycles; i
     assert.equal(retryResumeMode({}, false), true, 'cycle_pending undefined idle crash resumes strictly');
     assert.equal(retryResumeMode(null, false), true, 'no meta and no busy marker resumes strictly');
 });
-// ===========================================================================
-// The throttle's backoff schedule (pure): attempt n waits min(5s·2^(n-1), 10min);
-// zero consecutive failures respawn immediately (the sub-second yield respawn
-// D-3 buys). The stateful throttle behavior lives in respawn-throttle.test.ts.
-// ===========================================================================
-test('respawnBackoffMs: immediate at zero failures, doubling from 5s, capped at 10 minutes', () => {
-    assert.equal(respawnBackoffMs(0), 0);
-    assert.equal(respawnBackoffMs(1), 5_000);
-    assert.equal(respawnBackoffMs(2), 10_000);
-    assert.equal(respawnBackoffMs(3), 20_000);
-    assert.equal(respawnBackoffMs(5), 80_000);
-    assert.equal(respawnBackoffMs(20), 600_000, 'the backoff is capped, never unbounded');
-});
-test('throttle constants: healthy uptime is 60s; the loop terminalizes at 6 consecutive short-lived exits', () => {
-    assert.equal(HEALTHY_UPTIME_MS, 60_000);
-    assert.equal(MAX_RESPAWN_ATTEMPTS, 6);
-});

package/dist/core/__tests__/fixtures/fake-engine.d.ts

@@ -121,7 +121,7 @@ declare class FakeSession {
     private disposed;
     private eventSeq;
     private timer;
-    /** Full-tier graceful-teardown seam: a real active turn that only settles
+    /** Compiled-seam graceful-teardown vehicle: a real active turn that only settles
      * after abort(), so the broker's bounded abort wait is observable. */
     private heldTurn;
     private readonly listeners;

package/dist/core/__tests__/fixtures/fake-engine.js

@@ -269,7 +269,7 @@ class FakeSession {
     disposed = false;
     eventSeq = 0;
     timer;
-    /** Full-tier graceful-teardown seam: a real active turn that only settles
+    /** Compiled-seam graceful-teardown vehicle: a real active turn that only settles
      * after abort(), so the broker's bounded abort wait is observable. */
     heldTurn;
     // The broker's fan-out subscribers (broker.ts `session.subscribe(...)`) and the
@@ -306,7 +306,7 @@ class FakeSession {
         // Mirror the real pi SDK: a model-less construction (`model === undefined`)
         // does NOT leave `session.model` undefined — Agent.createMutableAgentState()
         // falls back to a hardcoded unknown-stub. Representing that here is what
-        // makes the full/ tests exercise the broker's real sessionHasNoModel()/
+        // makes the compiled seam tests exercise the broker's real sessionHasNoModel()/
         // isUnknownModel() guard path (broker.ts) rather than the `=== undefined`
         // shortcut that never happens against the real engine.
         this.currentModel = model ?? UNKNOWN_MODEL_STUB;

package/dist/core/__tests__/fixtures/fake-pi-host.js

@@ -7,8 +7,8 @@
 // and fires REAL lifecycle events under harness control, so the real hooks
 // drive real canvas state across the process boundary.
 //
-// The runtime exec's us exactly where it would exec `pi`, via the CRTR_PI_BINARY
-// seam in piCommand (src/core/runtime/tmux.ts). We therefore receive:
+// The runtime execs us exactly where it would exec `pi`, via the CRTR_PI_BINARY
+// seam in piCommand (src/core/runtime/tmux-driver.ts). We therefore receive:
 //   • argv:  -e <ext> … -n <label> [--session <path>] [--model …] [--tools …]
 //            [--append-system-prompt <file>] [<kickoff prompt>]   (buildPiArgv)
 //   • env:   CRTR_NODE_ID, CRTR_KIND, CRTR_MODE, CRTR_LIFECYCLE, CRTR_HOME,

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

@@ -3,12 +3,9 @@
 // The `focuses` table (canvas.db, migration v6) + its canvas setters + the
 // placement reads that compose over them. The table is the CANONICAL focus store
 // — there is no focus.ptr file and no dual-write bridge. Covers:
-//   - migration v6 adds `focuses` to a fresh db (and a legacy v5 db migrates up);
-//     idempotent / forward-only on re-run + re-open
+//   - migration v6 adds `focuses` to a fresh db
 //   - canvas setters/reads round-trip: open / setOccupant / setPane / close;
 //     getFocusByNode / getFocusByPane / getFocusById / listFocuses
-//   - UNIQUE(node_id): a second focus row (and an occupant UPDATE) for one node
-//     is rejected (upholds "a node occupies <=1 focus", Q5)
 //   - independent focus rows don't contend
 //   - placement focusOf / isFocused / focusByPane / focusedNodes / listFocuses
 //     GC dead-pane viewer rows on read (liveOrPrune), and pass null-pane rows
@@ -18,10 +15,8 @@ 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 { openFocusRow, setFocusOccupant, setFocusPane, closeFocusRow, getFocusByNode, getFocusByPane, getFocusById, listFocuses, } from '../canvas/focuses.js';
-import { openDb, closeDb, migrate, MIGRATIONS } from '../canvas/db.js';
-import { canvasDbPath, ensureHome } from '../canvas/paths.js';
+import { openDb, closeDb, MIGRATIONS } from '../canvas/db.js';
 import { focusOf, isFocused, focusByPane, focusedNodes, listFocuses as placementListFocuses, } from '../runtime/placement.js';
 let home;
 function userVersion(db) {
@@ -51,76 +46,6 @@ test('a fresh db migrates to the latest version and has the focuses table', () =
     assert.equal(userVersion(db), MIGRATIONS.length);
     assert.ok(tableNames(db).includes('focuses'), 'focuses table exists on a fresh db');
 });
-test('the focuses table has the v6 shape (UNIQUE node_id, nullable pane/session)', () => {
-    const db = openDb();
-    const cols = db.prepare('PRAGMA table_info(focuses)').all();
-    const byName = new Map(cols.map((c) => [c.name, c]));
-    assert.equal(byName.get('focus_id')?.pk, 1, 'focus_id is the primary key');
-    assert.equal(byName.get('node_id')?.notnull, 1, 'node_id is NOT NULL');
-    assert.equal(byName.get('pane')?.notnull, 0, 'pane is nullable');
-    assert.equal(byName.get('session')?.notnull, 0, 'session is nullable');
-    // node_id carries a UNIQUE index.
-    const idx = db.prepare('PRAGMA index_list(focuses)').all();
-    assert.ok(idx.some((i) => i.unique === 1), 'a UNIQUE index exists (the node_id constraint)');
-});
-test('a v5 db migrates forward, adding focuses without disturbing existing data', () => {
-    // Hand-build a db at exactly v5: baseline + the four v2 runtime columns + the
-    // v5 pane column + edges WITH the v4 FK shape, user_version=5 — the shape just
-    // before v6.
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    raw.exec(`
-    CREATE TABLE nodes (
-      node_id TEXT PRIMARY KEY, name TEXT NOT NULL, kind TEXT NOT NULL,
-      mode TEXT NOT NULL DEFAULT 'base', lifecycle TEXT NOT NULL DEFAULT 'terminal',
-      status TEXT NOT NULL DEFAULT 'active', cwd TEXT NOT NULL, parent TEXT,
-      created TEXT NOT NULL,
-      intent TEXT, pi_pid INTEGER, window TEXT, tmux_session TEXT, pane TEXT
-    );
-    CREATE TABLE edges (
-      type TEXT NOT NULL, from_id TEXT NOT NULL, to_id TEXT NOT NULL,
-      active INTEGER NOT NULL DEFAULT 1, created TEXT NOT NULL,
-      PRIMARY KEY (type, from_id, to_id),
-      FOREIGN KEY (from_id) REFERENCES nodes(node_id) ON DELETE CASCADE,
-      FOREIGN KEY (to_id)   REFERENCES nodes(node_id) ON DELETE CASCADE
-    );
-    PRAGMA user_version = 5;
-  `);
-    raw
-        .prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created, window, tmux_session, pane) VALUES (?,?,?,?,?,?,?,?,?)')
-        .run('legacy', 'Legacy', 'general', 'idle', '/tmp/work', '2020-01-01T00:00:00Z', '@9', 'crtr', '%3');
-    assert.equal(userVersion(raw), 5);
-    assert.ok(!tableNames(raw).includes('focuses'), 'precondition: no focuses table at v5');
-    raw.close();
-    // openDb() runs v6 forward.
-    const db = openDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    assert.ok(tableNames(db).includes('focuses'), 'focuses table added by v6');
-    // The pre-existing node row is intact (the v6 migration only adds a table).
-    const row = db
-        .prepare('SELECT status, window, tmux_session, pane FROM nodes WHERE node_id = ?')
-        .get('legacy');
-    assert.equal(row['status'], 'idle', 'existing status untouched');
-    assert.equal(row['window'], '@9', 'existing window untouched');
-    assert.equal(row['tmux_session'], 'crtr', 'existing session untouched');
-    assert.equal(row['pane'], '%3', 'existing pane untouched');
-    // The fresh focuses table is empty.
-    const n = db.prepare('SELECT COUNT(*) AS n FROM focuses').get().n;
-    assert.equal(n, 0, 'a fresh focuses table starts empty');
-});
-test('the v6 migration is idempotent / forward-only on re-run and re-open', () => {
-    const db = openDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-running migrate() is a no-op — the gate skips applied steps. The CREATE
-    // TABLE IF NOT EXISTS would be harmless anyway, but the gate must not re-fire.
-    assert.doesNotThrow(() => migrate(db));
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-opening from disk is likewise a no-op.
-    closeDb();
-    const db2 = openDb();
-    assert.equal(userVersion(db2), MIGRATIONS.length);
-    assert.ok(tableNames(db2).includes('focuses'));
-});
 // ---------------------------------------------------------------------------
 // Canvas setters / reads — open / setOccupant / setPane / close round-trip.
 // ---------------------------------------------------------------------------
@@ -148,25 +73,6 @@ test('open / setOccupant / close round-trip with the reads', () => {
     assert.equal(getFocusById('f1'), null);
     assert.deepEqual(listFocuses(), []);
 });
-test('UNIQUE(node_id): a second focus row for the same node is rejected', () => {
-    openDb();
-    openFocusRow('f1', '%a', 'Sa', 'A');
-    // A second viewport occupied by the SAME node violates UNIQUE(node_id) — this
-    // is the constraint that upholds "a node occupies <=1 focus" (Q5).
-    assert.throws(() => openFocusRow('f2', '%b', 'Sb', 'A'), /UNIQUE|constraint/i);
-    // The first row is untouched; no stray second row was created.
-    assert.deepEqual(listFocuses().map((f) => f.focus_id), ['f1']);
-});
-test('UNIQUE(node_id): hot-swapping an occupant onto an already-focused node is rejected', () => {
-    openDb();
-    openFocusRow('f1', '%a', 'Sa', 'A');
-    openFocusRow('f2', '%b', 'Sb', 'B');
-    // B already occupies f2 — moving it onto f1 via setFocusOccupant must throw
-    // (the Q5 vacate-first is placement.focus()'s job, not this setter's).
-    assert.throws(() => setFocusOccupant('f1', 'B'), /UNIQUE|constraint/i);
-    assert.deepEqual(getFocusByNode('A'), { focus_id: 'f1', pane: '%a', session: 'Sa', node_id: 'A' });
-    assert.deepEqual(getFocusByNode('B'), { focus_id: 'f2', pane: '%b', session: 'Sb', node_id: 'B' });
-});
 test('independent focus rows do not contend', () => {
     openDb();
     openFocusRow('f1', '%a', 'Sa', 'A');
@@ -185,8 +91,8 @@ test('independent focus rows do not contend', () => {
 // A row whose viewer pane no longer exists is pruned the next time it is read,
 // so the registry self-heals without a sweeper; a row with a null pane (a
 // registered-but-not-yet-realized viewer) is passed through. A live tmux pane
-// can't be fabricated in the fast tier, so we cover the prune + null-pane paths
-// here; the live-pane read is covered in the full-tier broker lifecycle suite.
+// can't be fabricated in the ordinary suite, so we cover the prune + null-pane paths
+// here; the live-pane read is covered in the compiled-seam broker lifecycle suite.
 // ---------------------------------------------------------------------------
 test('placement reads GC dead-pane viewer rows and keep null-pane rows', () => {
     openDb();

package/dist/core/__tests__/helpers/broker-clients.d.ts

@@ -6,9 +6,6 @@ export declare const delay: (ms: number) => Promise<void>;
 export declare const tok: (s: string) => string;
 export declare const frameHas: (f: BrokerToClient, token: string) => boolean;
 export declare function brokerLogText(h: Harness, id: string): string;
-/** lsof the holders of `path`, or null when lsof is unavailable (skip the fd
- *  check). Exit-non-zero with empty stdout means "no holders". */
-export declare function lsofHolders(path: string): number[] | null;
 export interface Attached {
     client: BrokerClient;
     frames: BrokerToClient[];

package/dist/core/__tests__/helpers/broker-clients.js

@@ -12,7 +12,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createConnection } from 'node:net';
-import { spawnSync } from 'node:child_process';
 import { BrokerClient } from '../../broker-client/index.js';
 import { CLIENT_READ_CAPS, FrameDecoder, encodeFrame, } from '../../runtime/broker-protocol.js';
 export const delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -30,19 +29,6 @@ export function brokerLogText(h, id) {
         return '';
     }
 }
-/** lsof the holders of `path`, or null when lsof is unavailable (skip the fd
- *  check). Exit-non-zero with empty stdout means "no holders". */
-export function lsofHolders(path) {
-    if (spawnSync('which', ['lsof'], { stdio: 'ignore' }).status !== 0)
-        return null;
-    const out = (spawnSync('lsof', ['-t', '--', path], { encoding: 'utf8' }).stdout ?? '').trim();
-    if (out === '')
-        return [];
-    return out
-        .split('\n')
-        .map((l) => Number(l.trim()))
-        .filter((n) => Number.isFinite(n));
-}
 /** Build the attach kit against a lazily-resolved harness (the harness is
  *  created in the file's before() hook, after the kit is constructed). */
 export function createAttachKit(getH) {

package/dist/core/__tests__/helpers/harness.d.ts

@@ -77,17 +77,12 @@ export interface Harness {
     session: string;
     spawnRoot(task: string, o?: SpawnOpts): string;
     fabricateBrokerNode(o?: FabricateOpts): string;
-    spawnChild(parentId: string, task: string, o?: SpawnOpts): Promise<string>;
     cli(nodeId: string | null, args: string[]): CliResult;
     spawnHeadlessChild(parentId: string, task: string, o?: SpawnOpts): Promise<string>;
-    spawnHeadlessChildNoBoot(parentId: string, task: string, o?: SpawnOpts): Promise<string>;
-    turn(nodeId: string, text?: string): Promise<void>;
     stop(nodeId: string, reason?: 'stop' | 'length' | 'aborted' | 'error', errorMessage?: string): Promise<void>;
-    finish(nodeId: string, finalText: string): Promise<void>;
     tick(now?: number): Promise<void>;
     fleet: DaemonFleet;
     deliverExit(nodeId: string, status?: FleetExitStatus): Promise<void>;
-    drainFleet(): Promise<void>;
     awaitFleetExit(nodeId: string, timeoutMs?: number): Promise<void>;
     awaitBoot(nodeId: string, o?: {
         minCount?: number;
@@ -98,12 +93,9 @@ export interface Harness {
         timeoutMs?: number;
         match?: RegExp;
     }): Promise<string[]>;
-    waitForStatus(nodeId: string, status: NodeStatus, timeoutMs?: number): Promise<void>;
-    waitForPaneGone(nodeId: string, timeoutMs?: number): Promise<void>;
     waitFor<T>(probe: () => T | undefined | null | false, o?: WaitOpts): Promise<T>;
     node(nodeId: string): NodeMeta | null;
     status(nodeId: string): NodeStatus | null;
-    paneAlive(nodeId: string): boolean;
     inbox(nodeId: string): InboxEntry[];
     injected(nodeId: string): Injected[];
     fakeCmd(nodeId: string, cmd: Record<string, unknown>): void;