@north-light/crouter 0.3.312 → 0.3.313

package/dist/daemon/review/sweep.js

@@ -1,136 +1,18 @@
-import { existsSync, readdirSync, rmSync } from 'node:fs';
-import { basename } from 'node:path';
-import { emitEvent } from '../../core/events/emit.js';
-import { reviewPath } from '../../core/human/convention.js';
-import { ticketDir } from '../../core/human/root.js';
-import { submitReview } from '../../core/human/tickets.js';
-import { reviewsRoot } from '../../core/canvas/paths.js';
-import { getNode } from '../../core/canvas/index.js';
-import { loadProfileManifest } from '../../core/profiles/manifest.js';
+import { requireVisibleReview } from '../../core/review/store.js';
 import { projectReviewResult } from '../../core/review/project.js';
 import { realizeReview } from '../../core/review/realize.js';
-import { listBindingReviews, listReviews, markProjected, markProjectionError, } from '../../core/review/store.js';
-import { ReviewOperationError } from '../../core/review/types.js';
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isMissingPath(error) {
-    return error?.code === 'ENOENT';
-}
-/** Republish the ticket projection only after its canonical review is already open. */
-function republishTicketReview(review) {
-    if (review.bridge_node_id === null)
-        throw new Error(`ticket review has no bridge node: ${review.review_id}`);
-    if (review.subtitle === null)
-        throw new Error(`ticket review has no subtitle: ${review.review_id}`);
-    const dir = ticketDir(review.bridge_node_id);
-    if (existsSync(reviewPath(dir)))
-        return;
-    const origin = getNode(review.origin_node_id);
-    if (origin === null)
-        throw new Error(`ticket review origin is missing: ${review.origin_node_id}`);
-    const profileName = origin.profile_id == null
-        ? undefined
-        : loadProfileManifest(origin.profile_id).manifest.name;
-    submitReview({
-        dir,
-        review: {
-            file: review.file,
-            ...(review.output_path === null ? {} : { output: review.output_path }),
-            title: basename(review.file),
-            subtitle: review.subtitle,
-            source: {
-                nodeId: review.origin_node_id,
-                ...(profileName === undefined ? {} : { profileName }),
-            },
-            blockedSince: review.created,
+import { retireCompanion } from '../companion-retire.js';
+import { sweepHumanRequests } from '../human/sweep.js';
+/** Compatibility entry point for daemon boot. All recovery is driven by human_requests. */
+export async function sweepReviews() {
+    return sweepHumanRequests({
+        realizeReview,
+        projectReview: (request) => {
+            const review = requireVisibleReview(request.request_id);
+            if (review.result_json === null)
+                throw new Error(`approved review lacks its immutable result: ${review.review_id}`);
+            projectReviewResult(review, JSON.parse(review.result_json));
         },
+        retireCompanion: async (nodeId, outcome) => { await retireCompanion(nodeId, outcome); },
     });
 }
-/** Reproject only an immutable, already-approved canonical result. */
-function reprojectApprovedReview(review) {
-    if (review.result_json === null)
-        throw new Error(`approved review lacks its immutable result: ${review.review_id}`);
-    projectReviewResult(review, JSON.parse(review.result_json));
-    markProjected(review.review_id, new Date().toISOString());
-}
-/** Remove only direct review directories that are no longer referenced by a row. */
-function collectOrphanReviewDirectories(reviewIds) {
-    let entries;
-    try {
-        entries = readdirSync(reviewsRoot(), { withFileTypes: true });
-    }
-    catch (error) {
-        if (isMissingPath(error))
-            return 0;
-        throw error;
-    }
-    let collected = 0;
-    for (const entry of entries) {
-        if (!entry.isDirectory() || reviewIds.has(entry.name))
-            continue;
-        rmSync(`${reviewsRoot()}/${entry.name}`, { recursive: true, force: true });
-        collected += 1;
-    }
-    return collected;
-}
-/**
- * Recover only pre-exposure review work at daemon startup. Terminal delivery and
- * retirement are intentionally outside this pass and require an explicit repeat.
- */
-export async function sweepReviews() {
-    let realized = 0;
-    let collected = 0;
-    let reprojected = 0;
-    let failed = 0;
-    const bindings = listBindingReviews();
-    for (const review of bindings) {
-        try {
-            await realizeReview(review.review_id);
-            realized += 1;
-        }
-        catch (error) {
-            // A missing immutable branch is an expected recovery outcome: realization
-            // cancels the binding and never captures a replacement branch.
-            if (!(error instanceof ReviewOperationError && error.code === 'branch_lost')) {
-                emitEvent({ level: 'warn', event: 'daemon.review_sweep.realize_failed', fields: { review_id: review.review_id, error: errorText(error) } });
-                failed += 1;
-            }
-        }
-    }
-    try {
-        const reviewIds = new Set([
-            ...listBindingReviews().map((review) => review.review_id),
-            ...listReviews({}).map((review) => review.review_id),
-        ]);
-        collected = collectOrphanReviewDirectories(reviewIds);
-    }
-    catch (error) {
-        emitEvent({ level: 'warn', event: 'daemon.review_sweep.collect_orphans_failed', fields: { error: errorText(error) } });
-        failed += 1;
-    }
-    for (const review of listReviews({ state: 'approved' })) {
-        if (review.projected_at !== null)
-            continue;
-        try {
-            reprojectApprovedReview(review);
-            reprojected += 1;
-        }
-        catch (error) {
-            markProjectionError(review.review_id, errorText(error));
-            failed += 1;
-        }
-    }
-    for (const review of listReviews({ state: 'open' })) {
-        if (review.origin_kind !== 'ticket')
-            continue;
-        try {
-            republishTicketReview(review);
-        }
-        catch (error) {
-            emitEvent({ level: 'warn', event: 'daemon.review_sweep.republish_failed', fields: { review_id: review.review_id, error: errorText(error) } });
-            failed += 1;
-        }
-    }
-    return { realized, collected, reprojected, failed };
-}

package/dist/daemon/startup-policy.d.ts

@@ -1,6 +1 @@
 export declare const DAEMON_STARTUP_WINDOW_MS: number;
-/** Exit code a daemon uses when startup hit a STANDING condition that retrying
- *  cannot clear (today: a blocked on-disk migration). Distinct from a generic
- *  failure so the spawner can stop retrying and surface the repair instead of
- *  respawning into the same wall. 78 is sysexits' EX_CONFIG. */
-export declare const DAEMON_EXIT_STARTUP_BLOCKED = 78;

package/dist/daemon/startup-policy.js

@@ -1,6 +1 @@
 export const DAEMON_STARTUP_WINDOW_MS = 5 * 60 * 1_000;
-/** Exit code a daemon uses when startup hit a STANDING condition that retrying
- *  cannot clear (today: a blocked on-disk migration). Distinct from a generic
- *  failure so the spawner can stop retrying and surface the repair instead of
- *  respawning into the same wall. 78 is sysexits' EX_CONFIG. */
-export const DAEMON_EXIT_STARTUP_BLOCKED = 78;

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export { reviveNode } from './core/runtime/revive.js';
 export type { ReviveResult } from './core/runtime/revive.js';
 export { closeNode } from './core/runtime/close.js';
 export type { CloseNodeResult } from './core/runtime/close.js';
-export { appendInbox } from './core/feed/inbox.js';
+export { enqueueNodeMail } from './core/feed/messages.js';
+export type { NodeMailInput } from './core/feed/messages.js';
 export type { InboxEntry, InboxTier, InboxKind } from './core/feed/inbox.js';
 export { appendSituationalContext } from './core/runtime/situational-context.js';
 export { isTurnInternal } from './core/runtime/turn-visibility.js';

package/dist/index.js

@@ -16,7 +16,7 @@
 // other caller (D-9), because an unbound launch throws by design (D-2).
 export { reviveNode } from './core/runtime/revive.js';
 export { closeNode } from './core/runtime/close.js';
-export { appendInbox } from './core/feed/inbox.js';
+export { enqueueNodeMail } from './core/feed/messages.js';
 // Hidden ambient "current situation" sidecar (see runtime/situational-context.ts) —
 // upsert-only, narrow surface so an external composer (e.g. Hearth) never needs to
 // learn the storage file itself.

package/dist/migrations/__tests__/activation-concurrency.test.js

@@ -36,6 +36,7 @@ function childActivation(home, release) {
     const { activateOnDiskMigrations } = await import(${JSON.stringify(moduleUrl)});
     await activateOnDiskMigrations({
       timeoutMs: 5000,
+      nodes: [],
       runner: async () => {
         writeFileSync(join(${JSON.stringify(home)}, 'entered.' + process.pid), '');
         while (!existsSync(${JSON.stringify(release)})) await new Promise((resolve) => setTimeout(resolve, 5));
@@ -107,9 +108,9 @@ test('activation and a forced migration serialize, and forced still runs after t
         }
     };
     try {
-        const activation = activateOnDiskMigrations({ timeoutMs: 1_000, runner });
+        const activation = activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner });
         await entered.promise;
-        const forced = runForcedOnDiskMigrations({ timeoutMs: 1_000, runner });
+        const forced = runForcedOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner });
         await delay(30);
         assert.equal(calls, 1);
         gate.resolve();

package/dist/migrations/__tests__/activation.test.js

@@ -37,13 +37,13 @@ test('activation skips only an exact current marker', async () => {
         let runs = 0;
         const runner = async () => { runs += 1; return result(); };
         writeFileSync(onDiskMigrationMarkerPath(), JSON.stringify(onDiskMigrationIdentity()));
-        assert.equal(await activateOnDiskMigrations({ timeoutMs: 1_000, runner }), null);
+        assert.equal(await activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner }), null);
         assert.equal(runs, 0);
         for (const invalid of [undefined, '{broken', JSON.stringify(onDiskMigrationIdentity().slice(0, -1))]) {
             rmSync(onDiskMigrationMarkerPath(), { force: true });
             if (invalid !== undefined)
                 writeFileSync(onDiskMigrationMarkerPath(), invalid);
-            assert.notEqual(await activateOnDiskMigrations({ timeoutMs: 1_000, runner }), null);
+            assert.notEqual(await activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner }), null);
         }
         assert.equal(runs, 3);
         assert.deepEqual(marker(), onDiskMigrationIdentity());
@@ -63,7 +63,7 @@ test('a superseded 003 identity reruns the corpus lane and the repository-root i
             { id: '002-profile-project-memory', lane: 'profile-manifest' },
             { id: '003-workspace-qualified-memory-identity', lane: 'corpus' },
         ]));
-        assert.notEqual(await activateOnDiskMigrations({ timeoutMs: 1_000, runner }), null, 'the superseded 003 identity must not satisfy activation');
+        assert.notEqual(await activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner }), null, 'the superseded 003 identity must not satisfy activation');
         assert.equal(runs, 1);
         const repositoryRootIdentity = [
             { id: '001-surfaces-frontmatter', lane: 'convergent' },
@@ -72,7 +72,7 @@ test('a superseded 003 identity reruns the corpus lane and the repository-root i
         ];
         assert.deepEqual(marker(), repositoryRootIdentity, 'the rerun records the repository-root identity in order');
         writeFileSync(onDiskMigrationMarkerPath(), JSON.stringify(repositoryRootIdentity));
-        assert.equal(await activateOnDiskMigrations({ timeoutMs: 1_000, runner }), null);
+        assert.equal(await activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner }), null);
         assert.equal(runs, 1, 'the repository-root marker skips the run');
     });
 });
@@ -94,6 +94,7 @@ test('forced runs ignore current markers while dry runs leave marker bytes untou
         let runs = 0;
         await runForcedOnDiskMigrations({
             timeoutMs: 1_000,
+            nodes: [],
             runner: async () => { runs += 1; return result(); },
         });
         assert.equal(runs, 1);
@@ -101,6 +102,7 @@ test('forced runs ignore current markers while dry runs leave marker bytes untou
         writeFileSync(onDiskMigrationMarkerPath(), '{malformed but preserved');
         await runForcedOnDiskMigrations({
             timeoutMs: 1_000,
+            nodes: [],
             dryRun: true,
             runner: async () => { runs += 1; return result({ verified: false }); },
         });
@@ -110,9 +112,9 @@ test('forced runs ignore current markers while dry runs leave marker bytes untou
 });
 test('failure leaves the marker absent and a later activation converges', async () => {
     await inHome(async () => {
-        await assert.rejects(activateOnDiskMigrations({ timeoutMs: 1_000, runner: async () => { throw new Error('interrupted'); } }), /interrupted/);
+        await assert.rejects(activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner: async () => { throw new Error('interrupted'); } }), /interrupted/);
         assert.equal(existsSync(onDiskMigrationMarkerPath()), false);
-        await activateOnDiskMigrations({ timeoutMs: 1_000, runner: async () => result() });
+        await activateOnDiskMigrations({ timeoutMs: 1_000, nodes: [], runner: async () => result() });
         assert.deepEqual(marker(), onDiskMigrationIdentity());
     });
 });
@@ -124,6 +126,7 @@ test('an unreadable profile blocker aborts startup effects with its path and rep
         const startup = async () => {
             await activateOnDiskMigrations({
                 timeoutMs: 1_000,
+                nodes: [],
                 runner: async () => result({
                     verified: false,
                     writes: [writtenPath],

package/dist/migrations/activation.d.ts

@@ -1,8 +1,10 @@
+import type { NodeMemoryTarget } from '../core/canvas/types.js';
 import { runOnDiskMigrations, type OnDiskMigrationRunResult } from './runner.js';
 export type OnDiskMigrationRunner = typeof runOnDiskMigrations;
 interface CoordinationOptions {
     timeoutMs?: number;
     runner?: OnDiskMigrationRunner;
+    nodes: readonly NodeMemoryTarget[];
 }
 export interface ForcedMigrationOptions extends CoordinationOptions {
     dryRun?: boolean;
@@ -18,8 +20,7 @@ export declare class MigrationBlockedError extends Error {
     constructor(message: string, blockerPaths: readonly string[]);
 }
 /** Run startup migration only when this home lacks the current completion marker. */
-export declare function activateOnDiskMigrations(options?: CoordinationOptions): Promise<OnDiskMigrationRunResult | null>;
-export declare function ensureOnDiskMigrations(): Promise<void>;
+export declare function activateOnDiskMigrations(options: CoordinationOptions): Promise<OnDiskMigrationRunResult | null>;
 /** Run migrations regardless of the marker; dry runs leave marker state untouched. */
 export declare function runForcedOnDiskMigrations(options: ForcedMigrationOptions): Promise<OnDiskMigrationRunResult>;
 export {};

package/dist/migrations/activation.js

@@ -64,6 +64,7 @@ async function coordinate(mode, options) {
         const result = await (options.runner ?? runOnDiskMigrations)({
             dryRun,
             explicitDirs: options.explicitDirs,
+            nodes: options.nodes,
         });
         if (!dryRun && result.finalVerificationSucceeded)
             writeCurrentMarker();
@@ -76,12 +77,9 @@ async function coordinate(mode, options) {
     });
 }
 /** Run startup migration only when this home lacks the current completion marker. */
-export async function activateOnDiskMigrations(options = {}) {
+export async function activateOnDiskMigrations(options) {
     return coordinate('activation', options);
 }
-export async function ensureOnDiskMigrations() {
-    await activateOnDiskMigrations();
-}
 /** Run migrations regardless of the marker; dry runs leave marker state untouched. */
 export async function runForcedOnDiskMigrations(options) {
     const result = await coordinate('forced', options);

package/dist/migrations/corpus.d.ts

@@ -1,3 +1,4 @@
+import type { NodeMemoryTarget } from '../core/canvas/types.js';
 import type { CorpusBlocker, CorpusDiscoveryRoot, CorpusIdentityRename, CorpusReferenceRewrite, CorpusRepositoryDecision, CorpusSnapshot, CorpusStore, CorpusStorePrefix, CorpusTarget, ProfileManifestSnapshot, StateMigration, StoreSnapshot } from './types.js';
 /** A store before its documents are read. */
 export type DiscoveredStore = Omit<CorpusStore, 'snapshot'>;
@@ -10,11 +11,6 @@ export interface CorpusDiscovery {
     targets: CorpusTarget[];
     /** Roots and targets discovery could not read. */
     blockers: CorpusBlocker[];
-    nodeMetadata: {
-        available: boolean;
-        nodes: number;
-        error?: string;
-    };
 }
 export interface CorpusSkippedDoc {
     storeRoot: string;
@@ -52,6 +48,7 @@ export declare function discoverCorpus(opts: {
     cwd?: string;
     profiles: readonly ProfileManifestSnapshot[];
     explicitDirs?: readonly string[];
+    nodes: readonly NodeMemoryTarget[];
 }): Promise<CorpusDiscovery>;
 /** Read every discovered store's documents. `preloaded` supplies the per-store
  *  convergent lane's FOLDED snapshots so the corpus plans against the bytes a

package/dist/migrations/corpus.js

@@ -12,16 +12,12 @@
 // the ENTIRE corpus. A store whose identity changed must not be readable at its
 // new address before every pointer to the old one has moved.
 //
-// Discovery is filesystem-only and never opens canvas.db. A migration runs
-// BEFORE the daemon on a cold home (Northlight's entrypoint does exactly that),
-// so node target metadata comes from each node's durable meta.json — the source
-// of truth the database index is rebuilt from — through its existing read-only
-// helper. Missing or corrupt metadata remains a global blocker.
+// Discovery is filesystem-only and never opens canvas.db. The daemon supplies
+// node target coordinates as plain values from its already-owned SQL roster.
 import { envProfileId } from '../shared/env.js';
 import { readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { readMetaObject } from '../core/canvas/meta-file.js';
-import { nodeMetaPath, nodesRoot } from '../core/canvas/paths.js';
+import { nodesRoot } from '../core/canvas/paths.js';
 import { atomicWriteText, listDirs, pathExists, realpathOrSelf, removePath, walkFiles } from '../core/fs-utils.js';
 import { memoryStoresInPrecedence, } from '../core/memory-resolver.js';
 import { descendantStoreRootsExhaustive } from '../core/nested-stores.js';
@@ -224,26 +220,20 @@ export async function discoverCorpus(opts) {
     const nodeStores = nodeStoresWithDocs();
     if (pathExists(nodesRoot()))
         addRoot({ reason: 'node', root: nodesRoot(), boundary: 'nodes' });
-    const nodeMetadata = { available: true, nodes: 0 };
+    const nodesById = new Map(opts.nodes.map((node) => [node.nodeId, node]));
     for (const { nodeId, storeRoot } of nodeStores) {
-        const metaPath = nodeMetaPath(nodeId);
-        const meta = readMetaObject(metaPath);
-        if (meta === null) {
-            nodeMetadata.available = false;
-            nodeMetadata.error ??= `unreadable metadata: ${metaPath}`;
+        const node = nodesById.get(nodeId);
+        if (node === undefined || node.cwd === '') {
+            const reason = node === undefined ? 'no row' : 'empty cwd';
             blockers.push({
                 kind: 'inaccessible-target',
-                message: `node ${nodeId} holds memory documents but its durable metadata is unreadable at ${metaPath} — restore or repair that file, then re-run`,
+                message: `node ${nodeId} holds memory documents but canvas.db has no usable row for it (${reason}) — the corpus cannot resolve its project or profile`,
                 storeRoot: realpathOrSelf(storeRoot),
-                path: metaPath,
             });
             register(nodeStoreDescriptor(storeRoot), { reason: 'node', root: storeRoot });
             continue;
         }
-        nodeMetadata.nodes += 1;
-        const nodeCwd = typeof meta['cwd'] === 'string' && meta['cwd'] !== '' ? meta['cwd'] : cwd;
-        const profileId = typeof meta['profile_id'] === 'string' && meta['profile_id'] !== '' ? meta['profile_id'] : null;
-        addTarget('node', nodeId, { cwd: nodeCwd, profileId, nodeId });
+        addTarget('node', nodeId, { cwd: node.cwd, profileId: node.profileId, nodeId });
     }
     // Runtime default `includeDescendants: false`: this is the store stack a link
     // or route actually resolves through. A descendant store is reached by its
@@ -334,7 +324,6 @@ export async function discoverCorpus(opts) {
             storeKeys: record.storeKeys,
         })),
         blockers,
-        nodeMetadata,
     };
 }
 // Snapshots

package/dist/migrations/runner.d.ts

@@ -1,3 +1,4 @@
+import type { NodeMemoryTarget } from '../core/canvas/types.js';
 import { type CorpusDiscovery } from './corpus.js';
 import type { CorpusBlocker, CorpusIdentityRename, CorpusRepositoryDecision, CorpusStorePrefix, CorpusReferenceRewrite, OnDiskMigrationLane, StoreSnapshot } from './types.js';
 export type OnDiskMigrationPhase = 'not-started' | 'planned' | 'written';
@@ -35,7 +36,8 @@ export interface OnDiskMigrationRunResult {
     finalVerificationSucceeded: boolean;
     dryRun: boolean;
 }
-export declare function runOnDiskMigrations(opts?: {
+export declare function runOnDiskMigrations(opts: {
     dryRun?: boolean;
     explicitDirs?: readonly string[];
+    nodes: readonly NodeMemoryTarget[];
 }): Promise<OnDiskMigrationRunResult>;

package/dist/migrations/runner.js

@@ -1,8 +1,9 @@
 import { profilesRoot, withProfileManifestLock } from '../core/profiles/manifest.js';
+import { resetScopeCache } from '../core/scope.js';
 import { buildCorpusSnapshot, discoverCorpus, loadCorpusSnapshots, parseFailureBlockers, runCorpusMigrations, } from './corpus.js';
 import { runConvergentMigrations } from './convergent.js';
 import { runProfileManifestMigrations } from './profile-manifests.js';
-export async function runOnDiskMigrations(opts = {}) {
+export async function runOnDiskMigrations(opts) {
     const dryRun = opts.dryRun === true;
     const applied = [];
     const skipped = [];
@@ -22,7 +23,10 @@ export async function runOnDiskMigrations(opts = {}) {
             path: row.path,
         });
     }
-    const discovery = await discoverCorpus({ profiles: profileRun.snapshots, explicitDirs: opts.explicitDirs });
+    // Corpus discovery must observe stores a preceding repair (or an external
+    // writer) created after this daemon last resolved a target's scope stack.
+    resetScopeCache();
+    const discovery = await discoverCorpus({ profiles: profileRun.snapshots, explicitDirs: opts.explicitDirs, nodes: opts.nodes });
     const parseFailures = [];
     const folded = new Map();
     for (const store of discovery.stores) {