@north-light/crouter 0.3.312 → 0.3.313

package/dist/commands/{sys/__tests__ → __tests__/integration}/migrate.test.js

@@ -3,10 +3,14 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import test from 'node:test';
 import { parse as parseYaml } from 'yaml';
 import { onDiskMigrationIdentity } from '../../../migrations/registry.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
+import { userStore } from '../../../core/scoped-state/paths.js';
+import { writeRawSettings } from '../../../core/scoped-state/settings.js';
+import { createSourceDaemonFixture, startSourceDaemon, waitForHealth, } from '../../../daemon/__tests__/helpers/source-daemon.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 const CLI = join(HERE, '../../../cli.ts');
 const TSX_LOADER = import.meta.resolve('tsx/esm');
@@ -49,8 +53,17 @@ function write(path, content) {
 }
 /** Store keys and target ids are realpaths, so the fixture must be one too:
  *  macOS hands `mkdtemp` a `/var/folders` path whose realpath is `/private/...`. */
+const migrateCanvasHomes = new Map();
 function fixtureHome(prefix) {
-    return realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+    const home = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    const root = mkdtempSync(join(tmpdir(), 'crtr-sys-migrate-daemon-'));
+    migrateCanvasHomes.set(home, join(root, 'canvas'));
+    return home;
+}
+function writeUserConfig(home, raw) {
+    const store = userStore(join(home, '.crouter'));
+    writeRawSettings({ store, key: 'user', kind: 'user', root: store.root }, raw);
 }
 /** Fixture git, with identity and signing pinned so the ambient user's global
  *  config cannot fail a commit this test needs. */
@@ -66,8 +79,11 @@ function initRepo(dir) {
     git(dir, 'add', 'README.md');
     git(dir, 'commit', '-m', 'fixture');
 }
+function canvasHomeFor(home) {
+    return migrateDaemons.get(home)?.fixture.canvasHome ?? migrateCanvasHomes.get(home) ?? join(home, '.crouter', 'canvas');
+}
 function markerPath(home) {
-    return join(home, '.crouter', 'canvas', 'on-disk-migrations.json');
+    return join(canvasHomeFor(home), 'on-disk-migrations.json');
 }
 function readMarker(home) {
     return JSON.parse(readFileSync(markerPath(home), 'utf8'));
@@ -112,11 +128,64 @@ function migrateEnv(home, profileId) {
         if (key.startsWith('CRTR_'))
             delete env[key];
     }
+    env['CRTR_HOME'] = canvasHomeFor(home);
     env['CRTR_PROFILE_ID'] = profileId;
+    env['CRTR_NO_DAEMON_AUTOSTART'] = '1';
     env['CRTR_NO_AUTO_INIT'] = '1';
     env['CRTR_NO_AUTO_UPDATE'] = '1';
     return env;
 }
+const migrateDaemons = new Map();
+async function startMigrateDaemon(home) {
+    const canvasHome = migrateCanvasHomes.get(home);
+    assert.ok(canvasHome, `fixture has no canvas home: ${home}`);
+    const fixture = await createSourceDaemonFixture({
+        root: dirname(canvasHome),
+        home,
+        cwd: home,
+        canvasHome,
+    });
+    const process = startSourceDaemon(fixture, { CRTR_PROFILE_ID: 'root-00000000' });
+    try {
+        await waitForHealth(process, fixture.tcpPort);
+    }
+    catch (error) {
+        await process.stop();
+        fixture.dispose();
+        throw error;
+    }
+    migrateDaemons.set(home, { fixture, process });
+}
+async function stopMigrateDaemon(home) {
+    const daemon = migrateDaemons.get(home);
+    if (daemon === undefined)
+        return;
+    migrateDaemons.delete(home);
+    const exit = await daemon.process.stop();
+    daemon.fixture.dispose();
+    migrateCanvasHomes.delete(home);
+    assert.deepEqual(exit, { code: 0, signal: null }, `migration daemon must stop cleanly; stderr:\n${daemon.process.stderr()}`);
+}
+function seedNodeMemoryTarget(home, target) {
+    const canvas = pathToFileURL(join(HERE, '../../../core/canvas/canvas.ts')).href;
+    const program = `
+    import { createNode } from ${JSON.stringify(canvas)};
+    const target = JSON.parse(process.argv[1]);
+    createNode({
+      node_id: target.nodeId,
+      name: target.nodeId,
+      created: new Date().toISOString(),
+      cwd: target.cwd,
+      kind: 'developer',
+      mode: 'base',
+      lifecycle: 'terminal',
+      status: 'done',
+      profile_id: target.profileId,
+    });
+  `;
+    const result = spawnSync(process.execPath, ['--conditions=crtr-src', '--import', TSX_LOADER, '--input-type=module', '--eval', program, JSON.stringify(target)], { cwd: home, env: migrateEnv(home, target.profileId ?? 'root-00000000'), encoding: 'utf8' });
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+}
 function runMigrate(home, opts = {}) {
     const result = spawnSync(process.execPath, [
         '--conditions=crtr-src',
@@ -186,7 +255,7 @@ function manifest(name, projects) {
         last_used_at: null,
     });
 }
-test('sys migrate converges manifests, documents, and the whole repository-root corpus', () => {
+test('sys migrate converges manifests, documents, and the whole repository-root corpus', async () => {
     const home = fixtureHome('crtr-sys-migrate-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
@@ -200,7 +269,7 @@ test('sys migrate converges manifests, documents, and the whole repository-root
     const embeddedPluginRoot = join(nestedOnlyProject, 'embedded', '.crouter', 'plugins', 'embedded-memory');
     const disabledPluginRoot = join(userRoot, 'plugins', 'disabled-memory');
     const nodeId = 'node-aaaa1111';
-    const nodeStore = join(userRoot, 'canvas', 'nodes', nodeId, 'context', 'memory');
+    const nodeStore = join(canvasHomeFor(home), 'nodes', nodeId, 'context', 'memory');
     const userDoc = join(userRoot, 'memory', 'user-link.md');
     const rootDoc = join(rootProfile, 'memory', 'root.md');
     const appletDoc = join(appletProfile, 'memory', 'identity.md');
@@ -215,6 +284,8 @@ test('sys migrate converges manifests, documents, and the whole repository-root
     const disabledPluginDoc = join(disabledPluginRoot, 'memory', 'guide.md');
     const nodeDoc = join(nodeStore, 'note.md');
     try {
+        await startMigrateDaemon(home);
+        seedNodeMemoryTarget(home, { nodeId, cwd: appletProject, profileId: 'applet-deadbeef' });
         // Root's string entries migrate to `preview`; every other profile's to
         // `content`. The applet manifest is mixed: its already-current entry must
         // survive untouched while the string beside it converts.
@@ -225,7 +296,7 @@ test('sys migrate converges manifests, documents, and the whole repository-root
         write(userDoc, `${OLD_DOC}\nSee [[user/scoped]].\n`);
         write(join(userRoot, 'memory', 'scoped', 'INDEX.md'), CURRENT_DOC);
         // Root profile store: an INDEX spelling to collapse, an unqualified project
-        // name to qualify, and a name its own target stack cannot see.
+        // name outside its own target stack, and a name its own target stack cannot see.
         write(rootDoc, `${OLD_DOC}\nSee [[notes/INDEX]], [[project]], and [[shared]].\n`);
         write(join(rootProfile, 'memory', 'notes', 'INDEX.md'), CURRENT_DOC);
         write(appletDoc, `${OLD_DOC}\nSee [[shared]].\n`);
@@ -267,12 +338,12 @@ See [[project]].
         write(embeddedPluginDoc, OLD_DOC);
         // A DISABLED plugin: no target mounts it, so its references resolve against
         // its own store alone — and it is still migrated.
-        write(join(userRoot, 'config.json'), JSON.stringify({ plugins: { 'disabled-memory': { enabled: false } } }));
+        writeUserConfig(home, { plugins: { 'disabled-memory': { enabled: false } } });
         write(join(disabledPluginRoot, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: 'disabled-memory', version: '1.0.0' }));
         write(join(disabledPluginRoot, 'memory', 'notes', 'INDEX.md'), CURRENT_DOC);
         write(disabledPluginDoc, `${CURRENT_DOC}\nSee [[disabled-memory/notes/INDEX]].\n`);
-        // A node store plus the durable meta.json the corpus reads with no daemon.
-        write(join(userRoot, 'canvas', 'nodes', nodeId, 'meta.json'), JSON.stringify({ node_id: nodeId, cwd: appletProject, profile_id: 'applet-deadbeef', kind: 'developer' }));
+        // A node store whose SQL row was seeded before its documents. No meta.json
+        // exists: corpus discovery must use the daemon-owned roster.
         write(nodeDoc, `${CURRENT_DOC}\nSee [[project]].\n`);
         // Reached by --dir only: no manifest names it and it is under no discovered
         // project root. Its `name:` is the FIRST frontmatter key, so the removal and
@@ -281,7 +352,7 @@ See [[project]].
         write(join(extraProject, '.crouter', 'memory', 'INDEX.md'), `---\nname: extra-dir-project\nkind: knowledge\n---\n# Extra Dir Project\n`);
         write(join(extraProject, '.crouter', 'memory', 'topic.md'), CURRENT_DOC);
         const invisible = migrateJson(home, { dryRun: true });
-        assert.equal(existsSync(markerPath(home)), false);
+        assert.deepEqual(readMarker(home), onDiskMigrationIdentity(), 'the daemon completed its empty-corpus startup before fixture bytes were seeded');
         assert.equal(invisible.discovered_stores.some((row) => row.store.startsWith(extraProject)), false, 'the --dir project must be outside the ambient discovery frontier');
         const output = migrateJson(home, { dirs: [extraProject] });
         assert.deepEqual(readMarker(home), onDiskMigrationIdentity());
@@ -301,8 +372,6 @@ See [[project]].
             assert.doesNotMatch(migrated, /system-prompt-visibility|file-read-visibility/);
             assert.match(migrated, /surfaces:\n  - on: boot\n    at: content/);
         }
-        // Durable node metadata, read with no daemon.
-        assert.deepEqual(output.node_metadata, { available: true, nodes: 1 });
         const nodeTarget = output.discovered_targets.find((row) => row.kind === 'node');
         assert.equal(nodeTarget?.node_id, nodeId);
         assert.equal(nodeTarget?.origin, nodeId);
@@ -379,7 +448,7 @@ surfaces:
         // completion.
         const rootDocText = readFileSync(rootDoc, 'utf8');
         assert.match(rootDocText, /\[\[notes\]\]/);
-        assert.match(rootDocText, /\[\[applet-project\/project\]\]/);
+        assert.match(rootDocText, /\[\[project\]\]/);
         assert.match(rootDocText, /\[\[shared\]\]/);
         assert.match(readFileSync(userDoc, 'utf8'), /\[\[user\/scoped\]\]/);
         assert.match(readFileSync(appletDoc, 'utf8'), /\[\[shared\]\]/);
@@ -442,6 +511,7 @@ See [[applet-project/project]].
         assertTreeUnchanged(converged, snapshotTree(home));
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
@@ -471,10 +541,12 @@ function seedConvergenceFixture(home, start) {
     write(join(nestedOwner, '.crouter', 'memory', 'INDEX.md'), supersededSyntheticIndex('pkg'));
     write(markerPath(home), JSON.stringify([{ id: '003-workspace-qualified-memory-identity', lane: 'corpus' }]));
 }
-test('pre-003 and superseded-003 corpora converge to the same bytes and the same current marker', () => {
+test('pre-003 and superseded-003 corpora converge to the same bytes and the same current marker', async () => {
     const preHome = fixtureHome('crtr-sys-migrate-conv-pre-');
     const oldHome = fixtureHome('crtr-sys-migrate-conv-old-');
     try {
+        await startMigrateDaemon(preHome);
+        await startMigrateDaemon(oldHome);
         seedConvergenceFixture(preHome, 'pre-003');
         seedConvergenceFixture(oldHome, 'superseded-003');
         const fromPre = migrateJson(preHome);
@@ -519,17 +591,20 @@ test('pre-003 and superseded-003 corpora converge to the same bytes and the same
         assert.equal(prefixRow(fromPre, join(preHome, 'conv-project', 'pkg')).nested_declaration_action, 'none');
     }
     finally {
+        await stopMigrateDaemon(preHome);
+        await stopMigrateDaemon(oldHome);
         rmSync(preHome, { recursive: true, force: true });
         rmSync(oldHome, { recursive: true, force: true });
     }
 });
-test('a repository declaration is kept when declared, derived from the root guide, or created when no root index exists', () => {
+test('a repository declaration is kept when declared, derived from the root guide, or created when no root index exists', async () => {
     const home = fixtureHome('crtr-sys-migrate-decisions-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const kept = join(home, 'kept-project');
     const derived = join(home, 'derived-project');
     const created = join(home, 'created-project');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [kept, derived, created].map((path) => ({ path, memory: 'content' }))));
         write(join(kept, '.crouter', 'memory', 'INDEX.md'), `---\nnamespace: kept-ns\nkind: knowledge\n---\n# Kept\n`);
         write(join(kept, '.crouter', 'memory', 'note.md'), CURRENT_DOC);
@@ -563,15 +638,17 @@ This project's memory store. Every document here answers at \`created-project/<l
         assert.equal(migrateJson(home).changed, 0);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a git repository whose only stores are descendants gets its repository-root declaration created', () => {
+test('a git repository whose only stores are descendants gets its repository-root declaration created', async () => {
     const home = fixtureHome('crtr-sys-migrate-git-descendant-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const repo = join(home, 'pkg-repo');
     const nestedOwner = join(repo, 'pkg');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: repo, memory: 'content' }]));
         initRepo(repo);
         write(join(nestedOwner, '.crouter', 'memory', 'note.md'), CURRENT_DOC);
@@ -590,19 +667,22 @@ test('a git repository whose only stores are descendants gets its repository-roo
         assert.deepEqual(output.store_prefixes.map((row) => [row.owner_dir, row.owner_relative_path, row.effective_prefix]), [[nestedOwner, 'pkg', 'pkg-repo/pkg']]);
         assert.match(readFileSync(join(repo, '.crouter', 'memory', 'INDEX.md'), 'utf8'), /^---\nnamespace: "pkg-repo"\n/);
         assert.equal(output.renames.some((row) => row.from === 'note' && row.to === 'pkg-repo/pkg/note'), true, JSON.stringify(output.renames));
-        assert.equal(migrateJson(home).changed, 0);
+        const second = migrateJson(home);
+        assert.equal(second.changed, 0, JSON.stringify(second.applied));
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('linked worktrees agree on one declaration, and a linked root missing one is filled from it', () => {
+test('linked worktrees agree on one declaration, and a linked root missing one is filled from it', async () => {
     for (const mode of ['agree', 'fill']) {
         const home = fixtureHome(`crtr-sys-migrate-worktree-${mode}-`);
         const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
         const main = join(home, 'shared-main');
         const linked = join(home, 'shared-linked');
         try {
+            await startMigrateDaemon(home);
             write(join(rootProfile, 'profile.json'), manifest('root', [main, linked].map((path) => ({ path, memory: 'content' }))));
             initRepo(main);
             git(main, 'worktree', 'add', linked, '-b', 'linked');
@@ -628,16 +708,18 @@ test('linked worktrees agree on one declaration, and a linked root missing one i
             assert.equal(migrateJson(home).changed, 0);
         }
         finally {
+            await stopMigrateDaemon(home);
             rmSync(home, { recursive: true, force: true });
         }
     }
 });
-test('linked worktree roots declaring different namespaces block the corpus', () => {
+test('linked worktree roots declaring different namespaces block the corpus', async () => {
     const home = fixtureHome('crtr-sys-migrate-worktree-conflict-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const main = join(home, 'shared-main');
     const linked = join(home, 'shared-linked');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [main, linked].map((path) => ({ path, memory: 'content' }))));
         initRepo(main);
         git(main, 'worktree', 'add', linked, '-b', 'linked');
@@ -656,10 +738,11 @@ test('linked worktree roots declaring different namespaces block the corpus', ()
         assertTreeUnchanged(before, snapshotTree(main));
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a nested declaration is removed, an exact synthetic index is deleted, and a substantive one is kept', () => {
+test('a nested declaration is removed, an exact synthetic index is deleted, and a substantive one is kept', async () => {
     const home = fixtureHome('crtr-sys-migrate-nested-declarations-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const project = join(home, 'nest-repo');
@@ -668,6 +751,7 @@ test('a nested declaration is removed, an exact synthetic index is deleted, and
     const syntheticIndex = join(syntheticOwner, '.crouter', 'memory', 'INDEX.md');
     const substantiveIndex = join(substantiveOwner, '.crouter', 'memory', 'INDEX.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         write(join(project, '.crouter', 'memory', 'INDEX.md'), `---\nnamespace: nest-repo\nkind: knowledge\n---\n# Nest Repo\n`);
         write(syntheticIndex, supersededSyntheticIndex('syn'));
@@ -684,16 +768,18 @@ test('a nested declaration is removed, an exact synthetic index is deleted, and
         assert.equal(migrateJson(home).changed, 0);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a rootless repository takes its front door from the one legacy guide that owns it', () => {
+test('a rootless repository takes its front door from the one legacy guide that owns it', async () => {
     const home = fixtureHome('crtr-sys-migrate-front-door-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const project = join(home, 'fd-root');
     const guide = join(project, '.crouter', 'memory', 'guide.md');
     const rootIndex = join(project, '.crouter', 'memory', 'INDEX.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         write(guide, `---
 kind: knowledge
@@ -751,10 +837,11 @@ The authored body, preserved byte for byte.
         assertTreeUnchanged(converged, snapshotTree(home));
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('repository-relative ordering prefixes do not block migration and derive canonical owner paths', () => {
+test('repository-relative ordering prefixes do not block migration and derive canonical owner paths', async () => {
     const home = fixtureHome('crtr-sys-migrate-ordering-prefix-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const repository = join(home, 'ordered-repository');
@@ -762,6 +849,7 @@ test('repository-relative ordering prefixes do not block migration and derive ca
     const rootIndex = join(repository, '.crouter', 'memory', 'INDEX.md');
     const nestedDoc = join(nestedOwner, '.crouter', 'memory', 'guide.md');
     try {
+        await startMigrateDaemon(home);
         initRepo(repository);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: repository, memory: 'content' }]));
         write(rootIndex, '---\nnamespace: acme\nkind: knowledge\n---\n# Repository\n');
@@ -772,10 +860,11 @@ test('repository-relative ordering prefixes do not block migration and derive ca
         assert.equal(prefixRow(output, nestedOwner).effective_prefix, 'acme/api');
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('the legacy front door is found in a nested store of the same repository, and a half-done transfer finishes', () => {
+test('the legacy front door is found in a nested store of the same repository, and a half-done transfer finishes', async () => {
     const home = fixtureHome('crtr-sys-migrate-front-door-nested-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const project = join(home, 'fd-nested');
@@ -784,6 +873,7 @@ test('the legacy front door is found in a nested store of the same repository, a
     const guide = join(nestedOwner, '.crouter', 'memory', 'guide.md');
     const legacyNamed = join(nestedOwner, '.crouter', 'memory', 'deep-note.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         write(rootIndex, `---\nnamespace: fd-nested\nkind: knowledge\n---\n# FD Nested\n`);
         write(guide, `---
@@ -850,10 +940,11 @@ surfaces:
         assert.doesNotMatch(readFileSync(guide, 'utf8'), /workspace-open/);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('two legacy front doors, and a root workspace-open that is not at content, each block the corpus', () => {
+test('two legacy front doors, and a root workspace-open that is not at content, each block the corpus', async () => {
     for (const shape of ['two-leaves', 'root-predicate']) {
         const home = fixtureHome(`crtr-sys-migrate-front-door-${shape}-`);
         const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
@@ -866,6 +957,7 @@ test('two legacy front doors, and a root workspace-open that is not at content,
     match: "./**"
     at: content`;
         try {
+            await startMigrateDaemon(home);
             write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
             if (shape === 'two-leaves') {
                 write(rootIndex, `---\nnamespace: fd-blocked\nkind: knowledge\n---\n# FD Blocked\n`);
@@ -896,16 +988,18 @@ test('two legacy front doors, and a root workspace-open that is not at content,
             assertTreeUnchanged(before, snapshotTree(project));
         }
         finally {
+            await stopMigrateDaemon(home);
             rmSync(home, { recursive: true, force: true });
         }
     }
 });
-test('a leaf carrying both the legacy front door and a translated route keeps every retained authored byte', () => {
+test('a leaf carrying both the legacy front door and a translated route keeps every retained authored byte', async () => {
     const home = fixtureHome('crtr-sys-migrate-front-door-compose-');
     const rootProfile = join(home, '.crouter', 'profiles', 'root-00000000');
     const project = join(home, 'compose-repo');
     const workspaceDoc = join(project, '.crouter', 'memory', 'workspace.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         // Pre-003 identity: nothing declares a namespace, so `topics/*` still names
         // the store's own documents and must be translated in the same pass that
@@ -966,15 +1060,17 @@ Body bytes that must survive both transforms.
         assert.equal(migrateJson(home).changed, 0);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('an unreadable profile manifest blocks forced completion and remains in skipped output', () => {
+test('an unreadable profile manifest blocks forced completion and remains in skipped output', async () => {
     const home = fixtureHome('crtr-sys-migrate-unreadable-profile-');
     const userRoot = join(home, '.crouter');
     const profileId = 'bad-deadbeef';
     const profilePath = join(userRoot, 'profiles', profileId, 'profile.json');
     try {
+        await startMigrateDaemon(home);
         write(profilePath, '{not json');
         write(markerPath(home), JSON.stringify(onDiskMigrationIdentity()));
         const payload = migrateBlocked(home);
@@ -991,16 +1087,18 @@ test('an unreadable profile manifest blocks forced completion and remains in ski
         assert.equal(existsSync(markerPath(home)), false);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('sys migrate blocks the whole corpus when one link names different documents per target, and writes nothing', () => {
+test('sys migrate blocks the whole corpus when one link names different documents per target, and writes nothing', async () => {
     const home = fixtureHome('crtr-sys-migrate-divergent-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
     const alpha = join(home, 'alpha-project');
     const beta = join(home, 'beta-project');
     try {
+        await startMigrateDaemon(home);
         // Already current for the manifest and document lanes: the only thing this
         // run could write is the corpus cut, so "nothing was written" is provable
         // byte for byte.
@@ -1045,13 +1143,13 @@ test('sys migrate blocks the whole corpus when one link names different document
             assert.ok(payload.received.renames.some((row) => row.store_root === store && row.to.startsWith(`${relative(home, project)}/`)), JSON.stringify(payload.received.renames));
         }
         assert.ok(Array.isArray(payload.received.references));
-        assert.equal(payload.received.node_metadata.available, true);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a corpus blocker never claims nothing was written when the earlier lanes already wrote', () => {
+test('a corpus blocker never claims nothing was written when the earlier lanes already wrote', async () => {
     const home = fixtureHome('crtr-sys-migrate-earlier-writes-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
@@ -1059,6 +1157,7 @@ test('a corpus blocker never claims nothing was written when the earlier lanes a
     const beta = join(home, 'beta-project');
     const userDoc = join(userRoot, 'memory', 'pointer.md');
     try {
+        await startMigrateDaemon(home);
         // A PRE-migration manifest and an old-format document, so the manifest and
         // convergent lanes both write before the corpus lane plans — and then one
         // `[[guide]]` naming a different document per target blocks that lane.
@@ -1086,10 +1185,11 @@ test('a corpus blocker never claims nothing was written when the earlier lanes a
         assertTreeUnchanged(projectsBefore, snapshotTree(alpha));
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a verification failure after both write phases reports the rewrites that are on disk', () => {
+test('a verification failure after both write phases reports the rewrites that are on disk', async () => {
     const home = fixtureHome('crtr-sys-migrate-verification-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
@@ -1097,6 +1197,7 @@ test('a verification failure after both write phases reports the rewrites that a
     const projectIndex = join(project, '.crouter', 'memory', 'INDEX.md');
     const strayDoc = join(project, '.crouter', 'memory', 'stray.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         write(projectIndex, `---\nkind: knowledge\n---\n# Verify Project\n`);
         // `namespace:` on a NON-root document: not an identity field this lane
@@ -1130,22 +1231,24 @@ surfaces:
 `);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a nested store reached only through a node target inherits the ancestor repository declaration', () => {
+test('a nested store reached only through a node target inherits the ancestor repository declaration', async () => {
     const home = fixtureHome('crtr-sys-migrate-node-nested-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
     const nodeId = 'node-bbbb2222';
-    const nodeStore = join(userRoot, 'canvas', 'nodes', nodeId, 'context', 'memory');
+    const nodeStore = join(canvasHomeFor(home), 'nodes', nodeId, 'context', 'memory');
     const nodeProject = join(home, 'node-cwd-project');
     const nestedOwner = join(nodeProject, 'nested');
     try {
-        // No project in any manifest and none above the cwd: the node's durable
-        // metadata is the ONLY path to this project root.
+        await startMigrateDaemon(home);
+        seedNodeMemoryTarget(home, { nodeId, cwd: nodeProject, profileId: 'root-00000000' });
+        // No project in any manifest and none above the cwd: the daemon's SQL row
+        // is the ONLY path to this project root.
         write(join(rootProfile, 'profile.json'), manifest('root', []));
-        write(join(userRoot, 'canvas', 'nodes', nodeId, 'meta.json'), JSON.stringify({ node_id: nodeId, cwd: nodeProject, profile_id: 'root-00000000', kind: 'developer' }));
         write(join(nodeStore, 'note.md'), CURRENT_DOC);
         write(join(nodeProject, '.crouter', 'memory', 'INDEX.md'), `---\nkind: knowledge\n---\n# Node Cwd Project\n`);
         write(join(nestedOwner, '.crouter', 'memory', 'topic.md'), CURRENT_DOC);
@@ -1165,16 +1268,18 @@ test('a nested store reached only through a node target inherits the ancestor re
         assert.equal(output.discovered_targets.some((row) => row.kind === 'project' && row.origin === nestedOwner), true);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });
-test('a memory-read route translates through an INDEX collapse and a root-plus-descendant split', () => {
+test('a memory-read route translates through an INDEX collapse and a root-plus-descendant split', async () => {
     const home = fixtureHome('crtr-sys-migrate-routes-');
     const userRoot = join(home, '.crouter');
     const rootProfile = join(userRoot, 'profiles', 'root-00000000');
     const project = join(home, 'route-project');
     const carrier = join(project, '.crouter', 'memory', 'carrier.md');
     try {
+        await startMigrateDaemon(home);
         write(join(rootProfile, 'profile.json'), manifest('root', [{ path: project, memory: 'content' }]));
         write(join(project, '.crouter', 'memory', 'INDEX.md'), `---\nkind: knowledge\n---\n# Route Project\n`);
         // `topics/INDEX` collapses onto `route-project/topics`, and `topics/**`
@@ -1219,6 +1324,7 @@ surfaces:
         assert.deepEqual(second.references, []);
     }
     finally {
+        await stopMigrateDaemon(home);
         rmSync(home, { recursive: true, force: true });
     }
 });

package/dist/commands/__tests__/revive-now-gate.test.js

@@ -7,6 +7,8 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { isNowEligibleFault } from '../node-lifecycle-revive.js';
 import { faultNeedsYou } from '../../core/canvas/status-glyph.js';
+// The gate reads the fault the daemon projected onto the node, so the fixture
+// builds the projected shape, not the wider parse-time one.
 function fault(over) {
     return {
         link: 'pi→provider',

package/dist/commands/api-client.d.ts

@@ -2,7 +2,8 @@ import { CrtrClient } from '../api/index.js';
 import type { CanvasSource } from '../core/canvas/source.js';
 import type { NodeStatus, SubscriptionRef } from '../core/canvas/types.js';
 import type { Scope } from '../types.js';
-import type { NodeDetailDTO, NodeSummaryDTO } from '../api/dto/nodes.js';
+import type { NodeDetailDTO } from '../api/dto/nodes.js';
+import type { NodeMeta, NodeRow } from '../core/canvas/types.js';
 /** Rethrow an `ApiError` as the clean structured CLI error agents parse
  *  (`core/io` `handle`) — instead of the generic "internal bug" stderr path a
  *  raw non-`CrtrError` throw would take. The mapping itself lives in ONE place
@@ -60,11 +61,11 @@ export declare class ApiCanvasSource implements CanvasSource {
     /** Map a 404 from the API to the interface's `null` "not found" contract;
      *  re-throw everything else. */
     private orNull;
-    getNode(nodeId: string): Promise<NodeDetailDTO | null>;
-    getRow(nodeId: string): Promise<NodeDetailDTO | null>;
+    getNode(nodeId: string): Promise<NodeMeta | null>;
+    getRow(nodeId: string): Promise<NodeRow | null>;
     listNodes(filter?: {
         status?: NodeStatus | NodeStatus[];
-    }): Promise<NodeSummaryDTO[]>;
+    }): Promise<NodeRow[]>;
     subscriptionsOf(subscriber: string): Promise<SubscriptionRef[]>;
     subscribersOf(publisher: string): Promise<SubscriptionRef[]>;
     /** BFS over the active `subscribes_to` edges from `root` (its transitive view),

package/dist/commands/api-client.js

@@ -19,12 +19,19 @@ import { join } from 'node:path';
 import { CrtrClient, ApiError } from '../api/index.js';
 import { apiErrorToCliError } from '../core/io.js';
 import { autostartDisabled, ensureDaemon } from '../daemon/manage.js';
-import { daemonStartupBlocked } from '../daemon/startup-block-marker.js';
 import { DAEMON_STARTUP_WINDOW_MS } from '../daemon/startup-policy.js';
 import { readState } from '../core/config.js';
 import { resolveRemoteCanvasTarget } from '../core/remote-canvas-target.js';
 import { RemoteCanvasSource } from '../core/canvas/remote-canvas-source.js';
 import { crtrHome } from '../core/canvas/paths.js';
+/** The API projects exactly the fault a node row carries; `api/` simply cannot
+ *  express the branded `operation_id` (it imports Node built-ins only), so the
+ *  wire value is asserted back to the row's fault type here rather than
+ *  reshaped. `broker↔crtrd` is deliberately absent from the wire link union: a
+ *  stored fault can never carry it. */
+function withRowFault(dto) {
+    return { ...dto, fault: (dto.fault ?? null) };
+}
 // Error translation
 /** Rethrow an `ApiError` as the clean structured CLI error agents parse
  *  (`core/io` `handle`) — instead of the generic "internal bug" stderr path a
@@ -127,9 +134,6 @@ export function cliClient(opts) {
         // On a cold-start timeout, enrich the bare `daemon_unavailable` with the
         // tail of crtrd's event log instead of discarding it.
         coldStartDiagnostic: readColdStartDiagnostic,
-        // A blocked startup is standing: every poll left in the window would report
-        // the same thing this already knows, so fail now and carry the repair.
-        coldStartAbort: daemonStartupBlocked,
         coldStartPollWindowMs: DAEMON_STARTUP_WINDOW_MS,
     });
 }
@@ -193,10 +197,12 @@ export class ApiCanvasSource {
         }
     }
     async getNode(nodeId) {
-        return this.orNull(() => this.client.getNode(nodeId));
+        const detail = await this.orNull(() => this.client.getNode(nodeId));
+        return detail === null ? null : withRowFault(detail);
     }
     async getRow(nodeId) {
-        return this.orNull(() => this.client.getNode(nodeId));
+        const detail = await this.orNull(() => this.client.getNode(nodeId));
+        return detail === null ? null : withRowFault(detail);
     }
     async listNodes(filter) {
         const status = filter?.status;
@@ -214,7 +220,7 @@ export class ApiCanvasSource {
         else {
             rows = await this.client.listNodes();
         }
-        return rows;
+        return rows.map((row) => withRowFault(row));
     }
     async subscriptionsOf(subscriber) {
         return this.roster().then((index) => index.subscriptions.get(subscriber) ?? []);