@north-light/crouter 0.3.311 → 0.3.313

package/dist/commands/human/review.js

@@ -1,9 +1,8 @@
 import { envNodeId } from '../../shared/env.js';
 import { randomUUID } from 'node:crypto';
-import { join, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
-import { ticketDir } from '../../core/human/root.js';
 import { cliClient } from '../api-client.js';
 function nodeActor() {
     const nodeId = envNodeId();
@@ -85,42 +84,33 @@ const humanReviewNew = defineLeaf({
         params: [
             { kind: 'positional', name: 'file', type: 'path', required: true, constraint: 'Document or source file to review. Resolved to an absolute path; the daemon validates that it is readable reviewable text.' },
             { kind: 'flag', name: 'subtitle', type: 'string', required: true, constraint: 'One plain-English sentence stating the review needed and why it matters.' },
-            { kind: 'flag', name: 'output', type: 'path', required: false, constraint: 'Where the immutable approval result JSON is projected. Default: <dir>/feedback.json.' },
         ],
         output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Ticket bridge node id. The approval is pushed to its origin when the person submits.' },
-            { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding the ticket projection and default approval result.' },
-            { name: 'output', type: 'string', required: true, constraint: 'Path where the immutable approval result JSON is projected.' },
             { name: 'review_id', type: 'string', required: true, constraint: 'Daemon-owned review id for the document, comments, and companion.' },
+            { name: 'review_dir', type: 'string', required: true, constraint: 'Directory containing the staged review and immutable result.json.' },
+            { name: 'result_path', type: 'string', required: true, constraint: 'The immutable terminal result path: <review_dir>/result.json.' },
             { name: 'follow_up', type: 'string', required: true, constraint: 'The review remains live for the person and companion; approval is delivered to the origin inbox.' },
         ],
         outputKind: 'object',
         effects: [
-            'The daemon creates the ticket bridge, durable review, and companion session fork.',
+            'The daemon creates the durable review and companion session fork.',
             'The reviewed file remains live in the attach viewer; this command does not submit an approval.',
         ],
     },
     run: async (input) => {
         const file = resolve(input['file']);
         const subtitle = requireSubtitle(input['subtitle']);
-        const outputArg = input['output'];
-        const output = typeof outputArg === 'string' ? resolve(outputArg) : undefined;
         const review = await cliClient().createReview({
             origin_kind: 'ticket',
             origin_node_id: requireOriginNode(),
             file,
             idempotency_key: randomUUID(),
             subtitle,
-            ...(output === undefined ? {} : { output_path: output }),
         });
-        if (review.bridge_node_id === null)
-            throw new Error('ticket review was created without a bridge node');
-        const dir = ticketDir(review.bridge_node_id);
         return {
-            job_id: review.bridge_node_id,
-            dir,
-            output: output ?? join(dir, 'feedback.json'),
             review_id: review.review_id,
+            review_dir: review.review_dir,
+            result_path: `${review.review_dir}/result.json`,
             follow_up: 'The review is live for the person in the attach viewer with its companion agent. Approval is pushed to the origin inbox when submitted.',
         };
     },

package/dist/commands/memory/__tests__/command-selector-and-mutation-guards.test.js

@@ -20,6 +20,7 @@ import { join } from 'node:path';
 import { resetScopeCache } from '../../../core/scope.js';
 import { closeDb } from '../../../core/canvas/db.js';
 import { createProfile, profileMemoryDir } from '../../../core/profiles/manifest.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
 import { openProjectMemoryStore } from '../../../core/memory-resolver.js';
 import { appendHistoryRecord, buildHistoryRecord, readHistoryRecords } from '../../../core/memory/history.js';
 import { CrtrError } from '../../../core/errors.js';
@@ -74,6 +75,7 @@ beforeEach(() => {
     process.env['CRTR_HOME'] = canvasHome;
     delete process.env['CRTR_NODE_ID'];
     mkdirSync(join(home, '.crouter', 'memory'), { recursive: true });
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
     root = join(base, 'root');
     child = join(root, 'child');
     nestedWrite = join(root, 'nested-write');

package/dist/commands/memory/__tests__/memory-list-and-lint-ignore.test.js

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { parseFrontmatterGeneric } from '../../../core/frontmatter.js';
 import { resetScopeCache } from '../../../core/scope.js';
 import { CrtrError } from '../../../core/errors.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
 import { editLeaf } from '../edit.js';
 import { listLeaf } from '../list.js';
 import { writeLeaf } from '../write.js';
@@ -16,6 +17,7 @@ const canvasHome = mkdtempSync(join(tmpdir(), 'crtr-memory-list-canvas-'));
 mkdirSync(join(home, '.crouter', 'memory'), { recursive: true });
 process.env['HOME'] = home;
 process.env['CRTR_HOME'] = canvasHome;
+initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
 function writeMemory(name, frontmatter = 'kind: knowledge') {
     writeFileSync(join(home, '.crouter', 'memory', name), `---\n${frontmatter}\n---\n\nBODY\n`, 'utf8');
 }

package/dist/commands/memory/__tests__/repository-root-lint.test.js

@@ -12,6 +12,7 @@ import { closeDb } from '../../../core/canvas/db.js';
 import { lintMemoryStore, lintMemoryTarget } from '../../../core/memory/lint.js';
 import { openProjectMemoryStore } from '../../../core/memory-resolver.js';
 import { createProfile } from '../../../core/profiles/manifest.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
 import { resetScopeCache } from '../../../core/scope.js';
 let home;
 let canvasHome;
@@ -54,6 +55,7 @@ beforeEach(() => {
     delete process.env['CRTR_PROFILE_ID'];
     delete process.env['CRTR_NODE_ID'];
     mkdirSync(join(home, '.crouter', 'memory'), { recursive: true });
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
     resetScopeCache();
 });
 after(() => {

package/dist/commands/node-inspect-artifacts.js

@@ -39,7 +39,7 @@ export const nodeArtifactsLeaf = defineLeaf({
         summary: 'list one node\'s artifacts (reports + context docs) as refs ready for `canvas history read`',
         params: [
             { kind: 'positional', name: 'node-id', required: true, constraint: 'The node whose artifacts to list.' },
-            { kind: 'flag', name: 'type', type: 'enum', choices: [...TYPES], required: false, constraint: 'Narrow to one corpus: report | doc | roadmap | inbox. Default: report, doc, roadmap (inbox is opt-in only — the node\'s raw inbox.jsonl history, cursor-independent and including full un-clipped direct-message bodies; a diagnostic surface, not curated past work).' },
+            { kind: 'flag', name: 'type', type: 'enum', choices: [...TYPES], required: false, constraint: 'Narrow to one corpus: report | doc | roadmap | inbox. Default: report, doc, roadmap (inbox is opt-in only — the node\'s inbox history including full un-clipped direct-message bodies; a diagnostic surface, not curated past work).' },
             { kind: 'flag', name: 'sort', type: 'enum', choices: ['recency', 'oldest'], required: false, constraint: 'Order by artifact timestamp. Default recency.' },
         ],
         output: [

package/dist/commands/node-lifecycle-revive.d.ts

@@ -1,5 +1,5 @@
 import type { LeafDef } from '../core/command.js';
-import type { Fault } from '../core/runtime/fault.js';
+import type { NodeFaultDTO } from '../api/dto/nodes.js';
 /** --now eligibility for a live, non-busy fault: a daemon-owned AUTO retry
  *  (kick it early instead of waiting out the schedule), or any fault the
  *  canvas dashboard flags "needs you" (`faultNeedsYou`, status-glyph.ts) — the
@@ -8,5 +8,5 @@ import type { Fault } from '../core/runtime/fault.js';
  *  (redialing) already in flight, and refuses any OTHER link — notably a
  *  `daemon→node` wedge fault, which --now can't clear (SIGTERM doesn't touch
  *  the runaway subprocess; see `wedged-child-on-runaway-bash`). */
-export declare function isNowEligibleFault(fault: Fault | null): boolean;
+export declare function isNowEligibleFault(fault: NodeFaultDTO | null): boolean;
 export declare const nodeReviveLeaf: LeafDef;

package/dist/commands/node-lifecycle-revive.js

@@ -15,8 +15,6 @@
 // The mass-recovery form — reconnect EVERY disconnected node at once after a
 // reboot/crash — is genuinely graph-wide and stays at `canvas revive --all`
 // (src/commands/revive.ts).
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import { defineLeaf } from '../core/command.js';
 import { InputError } from '../core/io.js';
 import { cliClient, rethrowAsCliError } from './api-client.js';
@@ -25,17 +23,16 @@ import { cliClient, rethrowAsCliError } from './api-client.js';
 // accessors — a `crtr` CLI process never opens canvas.db. So the revive itself
 // goes through the daemon (`cliClient().reviveNode`), and every helper below is
 // imported from a db-free module: `recordedPidLiveness` (pid.js → fs/ps only),
-// `readFault` (fault.js → paths.js pure helpers + events), `faultNeedsYou`
-// (status-glyph.js → fault.js), and `fullName` from labels.js DIRECTLY (NOT the
-// canvas barrel `index.js`, which re-exports `openDb`). `jobDir` is a pure path
-// helper, and view-socket readiness comes from the db-free probe owner. The former
-// direct `reviveNode`/`getNode`/`assertReopenGate`/`waitForBrokerViewSocket`/`isBusy`
+// `faultNeedsYou` (status-glyph.js → fault.js), and `fullName` from labels.js
+// DIRECTLY (NOT the canvas barrel `index.js`, which re-exports `openDb`).
+// View-socket readiness comes from the db-free probe owner. The node's active
+// fault and mid-turn state are projected fields on the detail DTO this leaf
+// already fetches. The former direct
+// `reviveNode`/`getNode`/`assertReopenGate`/`waitForBrokerViewSocket`/`isBusy`
 // imports all reached the db barrel and are replaced by the client call + helpers below.
 import { recordedPidLiveness } from '../core/canvas/pid.js';
-import { readFault } from '../core/runtime/fault.js';
 import { fullName } from '../core/canvas/labels.js';
 import { faultNeedsYou } from '../core/canvas/status-glyph.js';
-import { jobDir } from '../core/canvas/paths.js';
 import { waitForViewSocketReady } from '../core/runtime/view-socket.js';
 /** --now eligibility for a live, non-busy fault: a daemon-owned AUTO retry
  *  (kick it early instead of waiting out the schedule), or any fault the
@@ -52,13 +49,6 @@ export function isNowEligibleFault(fault) {
         return true;
     return fault.retry.by === 'daemon';
 }
-// Local, db-free helpers (inlined so the leaf never imports the canvas barrel)
-/** Inlined from `runtime/busy.ts` (which reaches the canvas barrel via `jobDir`):
- * is the node mid-turn right now? `<jobDir>/busy` exists for the span pi is
- * inside a run. `jobDir` here is the pure path helper from paths.js. */
-function nodeIsBusy(nodeId) {
-    return existsSync(join(jobDir(nodeId), 'busy'));
-}
 export const nodeReviveLeaf = defineLeaf({
     name: 'revive',
     description: 'reopen a window for a done/idle/dead/canceled node',
@@ -157,7 +147,7 @@ export const nodeReviveLeaf = defineLeaf({
                 rethrowAsCliError(e);
             }
             const pid = detail.pi_pid;
-            const stall = readFault(nodeId);
+            const stall = detail.fault ?? null;
             if (pid == null || recordedPidLiveness(pid, detail.pi_pid_identity ?? null) !== 'alive') {
                 throw new InputError({
                     error: 'not_hanging',
@@ -173,9 +163,9 @@ export const nodeReviveLeaf = defineLeaf({
                 });
             }
             // The daemon never kills a BUSY engine (its verdict paths all return 'leave'
-            // on a live busy marker): a node mid-turn is making progress, not wedged —
+            // on an open turn): a node mid-turn is making progress, not wedged —
             // refuse rather than SIGTERM it mid-flight.
-            if (nodeIsBusy(nodeId)) {
+            if (detail.streaming === true) {
                 throw new InputError({
                     error: 'busy',
                     message: `${nodeId} is mid-turn right now (busy) — --now refuses to SIGTERM a working engine; it has recovered on its own.`,

package/dist/commands/pkg/plugin-manage.js

@@ -199,7 +199,6 @@ function migratePluginMemory(manifest, root, scope, where, ownership) {
             }],
         targets: [],
         blockers: [],
-        nodeMetadata: { available: true, nodes: 0 },
     };
     const load = () => {
         const { snapshots, skipped } = loadCorpusSnapshots(discovery);

package/dist/commands/profile/show.js

@@ -1,15 +1,12 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import { defineLeaf } from '../../core/command.js';
 import { resolveProfileOperand, profileRoot, sanitizeProfileMetadata } from '../../core/profiles/manifest.js';
-import { CONFIG_FILE } from '../../types.js';
 export const showLeaf = defineLeaf({
     name: 'show',
     description: "one profile's manifest in full",
     whenToUse: "you need a profile's full project list, home directory, id, and timestamps — after `profile list` narrows to a name, to find where its nodes will run, or to inspect what a node's bearings named as its profile.",
     help: {
         name: 'profile show',
-        summary: "print one profile's manifest plus its on-disk path and config.json location",
+        summary: "print one profile's manifest and on-disk path",
         params: [
             {
                 kind: 'positional',
@@ -29,16 +26,13 @@ export const showLeaf = defineLeaf({
             { name: 'created_at', type: 'string', required: true, constraint: 'ISO 8601 creation timestamp.' },
             { name: 'last_used_at', type: 'string | null', required: true, constraint: 'ISO 8601 timestamp of the most recent selection, or null if never selected.' },
             { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the profile directory.' },
-            { name: 'config_path', type: 'string', required: true, constraint: 'Absolute path to the profile\'s config.json (hand-edited the same way as user/project config.json — no profile-specific editor verb exists).' },
-            { name: 'config_exists', type: 'boolean', required: true, constraint: 'Whether config.json exists at that path yet.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Concrete next commands.' },
+            { name: 'follow_up', type: 'string', required: true, constraint: 'Concrete next commands, including the SQL-backed raw settings surface.' },
         ],
         outputKind: 'object',
         effects: ['None. Read-only.'],
     },
     run: async (input) => {
         const { profileId, manifest } = resolveProfileOperand(input['profile']);
-        const configPath = join(profileRoot(profileId), CONFIG_FILE);
         return {
             profile_id: profileId,
             name: manifest.name,
@@ -50,11 +44,9 @@ export const showLeaf = defineLeaf({
             created_at: manifest.created_at,
             last_used_at: manifest.last_used_at,
             path: profileRoot(profileId),
-            config_path: configPath,
-            config_exists: existsSync(configPath),
             follow_up: manifest.paused_at === null
-                ? `Manage its purview and automatic memory disclosure with \`crtr profile project add ${profileId} --dir <path> --memory <none|name|preview|content>\`, pause it with \`crtr profile pause ${profileId}\`, or set its default kind with \`crtr profile kind ${profileId} <kind>\`.`
-                : `Manage its purview and automatic memory disclosure with \`crtr profile project add ${profileId} --dir <path> --memory <none|name|preview|content>\`, or resume it with \`crtr profile resume ${profileId}\`.`,
+                ? `Inspect its SQL-backed settings with \`crtr sys config get-raw --scope profile --profile ${profileId}\`; manage its purview with \`crtr profile project add ${profileId} --dir <path> --memory <none|name|preview|content>\`, pause it with \`crtr profile pause ${profileId}\`, or set its default kind with \`crtr profile kind ${profileId} <kind>\`.`
+                : `Inspect its SQL-backed settings with \`crtr sys config get-raw --scope profile --profile ${profileId}\`; manage its purview with \`crtr profile project add ${profileId} --dir <path> --memory <none|name|preview|content>\`, or resume it with \`crtr profile resume ${profileId}\`.`,
         };
     },
 });

package/dist/commands/surface-tmux-spread.js

@@ -49,11 +49,7 @@ async function climbRootViaSource(source, self) {
 }
 /** Hard ceiling on panes in the spread window (self + up to 7 siblings). */
 const PANE_CAP = 8;
-/** Recency key for ranking: the mtime of a node's job/telemetry.json — rewritten
- *  on every turn_end at a DETERMINISTIC node-id-derived path (unlike pi_session_file,
- *  whose path lives in meta.json and is NOT projected by the API's NodeMeta). This
- *  is the same last-activity proxy the dashboard recency sort uses; a node that
- *  never ran a turn (no telemetry) sorts last (0). Local statSync, openDb-free. */
+/** Telemetry mtime approximates last activity; nodes without telemetry sort last. */
 function sessionMtime(nodeId) {
     try {
         const st = statSync(join(jobDir(nodeId), 'telemetry.json'), { throwIfNoEntry: false });

package/dist/commands/sys/__tests__/config-model-ladders.test.js

@@ -1,8 +1,8 @@
 // config-model-ladders.test.ts — regression coverage for the live Hearth
-// incident where a home's config.json had `openai-codex/gpt-5.6-*` baked into
+// incident where a home's stored config had `openai-codex/gpt-5.6-*` baked into
 // `modelLadders` while the guest's own installed model registry only had
 // `gpt-5.5`. Root cause: both `ensureScopeInitialized` (fresh scope) and
-// `sys config set modelLadders...` (a targeted edit) persisted the FULLY
+// `sys config set modelLadders...` (a targeted edit) persisted the fully
 // materialized ladder (all 4 strengths x 2 providers) rather than only the
 // genuine override, freezing whatever concrete model ids happened to be
 // compiled into the crouter build that ran at that moment. A later
@@ -10,10 +10,10 @@
 // reach the frozen rungs again.
 import { test, before, after, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { ensureScopeInitialized, readConfig, updateConfig } from '../../../core/config.js';
+import { ensureScopeInitialized, readConfig, readRawScopeConfig, updateConfig } from '../../../core/config.js';
 import { configBranch } from '../config.js';
 function leaf(name) {
     const found = (configBranch.children ?? []).find((c) => c.name === name);
@@ -41,16 +41,13 @@ after(() => {
     else
         delete process.env['HOME'];
 });
-test('ensureScopeInitialized does NOT bake concrete modelLadders model ids into a fresh config.json', () => {
+test('ensureScopeInitialized does NOT bake concrete modelLadders model ids into a fresh scoped store', () => {
     const root = join(home, '.crouter');
     ensureScopeInitialized('user', root);
-    const cfgPath = join(root, 'config.json');
-    assert.equal(existsSync(cfgPath), true);
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
-    // The file must exist (so `sys config path` has something to point at) but
-    // must NOT freeze a modelLadders snapshot -- that key should be absent so
-    // `readConfig` always re-derives it live from whichever build is running.
-    assert.equal(raw.modelLadders, undefined);
+    const raw = readRawScopeConfig('user');
+    // A fresh store has no settings row until a caller writes an override, so
+    // `readConfig` always re-derives the ladder from the running build.
+    assert.equal(raw?.modelLadders, undefined);
     // readConfig must still default-fill a full, usable ladder despite the
     // omission -- a config-less scope is never worse off.
     const cfg = readConfig('user');
@@ -61,17 +58,16 @@ test('sys config set modelLadders.<provider>.<strength> persists ONLY the touche
     const root = join(home, '.crouter');
     ensureScopeInitialized('user', root);
     await leaf('set').run({ key: 'modelLadders.openai.strong', value: 'openai-codex/gpt-5.5:high' });
-    const cfgPath = join(root, 'config.json');
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
-    assert.equal(raw.modelLadders.openai.strong, 'openai-codex/gpt-5.5:high');
+    const raw = readRawScopeConfig('user');
+    assert.equal(raw.modelLadders?.openai?.strong, 'openai-codex/gpt-5.5:high');
     // The other three openai rungs, and the entire anthropic ladder, must stay
     // UNSET on disk -- baking them in would freeze this scope to today's
     // compiled defaults for rungs the user never touched, the exact staleness
     // bug that produced the live `gpt-5.6` vs. installed-`gpt-5.5` mismatch.
-    assert.equal(raw.modelLadders.openai.ultra, undefined);
-    assert.equal(raw.modelLadders.openai.medium, undefined);
-    assert.equal(raw.modelLadders.openai.light, undefined);
-    assert.equal(raw.modelLadders.anthropic, undefined);
+    assert.equal(raw.modelLadders?.openai?.ultra, undefined);
+    assert.equal(raw.modelLadders?.openai?.medium, undefined);
+    assert.equal(raw.modelLadders?.openai?.light, undefined);
+    assert.equal(raw.modelLadders?.anthropic, undefined);
     // readConfig still resolves a full ladder: the one override layered over
     // live compiled defaults for everything else.
     const cfg = readConfig('user');
@@ -91,17 +87,15 @@ test('an unrelated updateConfig mutation (as fresh bootstrap does) does NOT free
             installed_at: '2026-01-01T00:00:00.000Z',
         };
     });
-    const cfgPath = join(root, 'config.json');
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    const raw = readRawScopeConfig('user');
     assert.equal(raw.modelLadders, undefined);
-    assert.ok(raw.marketplaces['crouter-official-marketplace']);
+    assert.ok(raw.marketplaces?.['crouter-official-marketplace']);
 });
 test('a non-ladder sys config set does NOT freeze modelLadders to disk', async () => {
     const root = join(home, '.crouter');
     ensureScopeInitialized('user', root);
     await leaf('set').run({ key: 'max_panes_per_window', value: '5' });
-    const cfgPath = join(root, 'config.json');
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    const raw = readRawScopeConfig('user');
     // The touched key persists; modelLadders stays absent so a later build's
     // registry change still reaches every rung.
     assert.equal(raw.max_panes_per_window, 5);
@@ -112,10 +106,9 @@ test('a second sys config set for a different rung does not clobber an earlier o
     ensureScopeInitialized('user', root);
     await leaf('set').run({ key: 'modelLadders.openai.strong', value: 'openai-codex/gpt-5.5:high' });
     await leaf('set').run({ key: 'modelLadders.anthropic.light', value: 'anthropic/claude-haiku-4-5:high' });
-    const cfgPath = join(root, 'config.json');
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
-    assert.equal(raw.modelLadders.openai.strong, 'openai-codex/gpt-5.5:high');
-    assert.equal(raw.modelLadders.anthropic.light, 'anthropic/claude-haiku-4-5:high');
-    assert.equal(raw.modelLadders.openai.ultra, undefined);
-    assert.equal(raw.modelLadders.anthropic.strong, undefined);
+    const raw = readRawScopeConfig('user');
+    assert.equal(raw.modelLadders?.openai?.strong, 'openai-codex/gpt-5.5:high');
+    assert.equal(raw.modelLadders?.anthropic?.light, 'anthropic/claude-haiku-4-5:high');
+    assert.equal(raw.modelLadders?.openai?.ultra, undefined);
+    assert.equal(raw.modelLadders?.anthropic?.strong, undefined);
 });

package/dist/commands/sys/__tests__/sync-project-guidance.test.js

@@ -7,6 +7,10 @@ import { fileURLToPath } from 'node:url';
 import test from 'node:test';
 import { lintMemoryStore } from '../../../core/memory/lint.js';
 import { openProjectMemoryStore } from '../../../core/memory-resolver.js';
+import { insertStoredProfile } from '../../../core/scoped-state/profiles.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
+import { closeScopedStores } from '../../../core/scoped-state/db.js';
+import { resetScopeCache } from '../../../core/scope.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 const CLI = join(HERE, '../../../cli.ts');
 const TSX_LOADER = import.meta.resolve('tsx/esm');
@@ -17,7 +21,9 @@ 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/...`. */
 function fixtureHome(prefix) {
-    return realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+    const home = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    return home;
 }
 /** A home the ambient node's own CRTR_* environment cannot leak into. */
 function syncEnv(home) {
@@ -58,15 +64,35 @@ function initializeRepository(path) {
     assert.equal(result.status, 0, result.stderr);
 }
 function writeProfile(home, profileId, project) {
-    write(join(home, '.crouter', 'profiles', profileId, 'profile.json'), JSON.stringify({
-        schema_version: 4,
-        name: 'sync fixture',
-        projects: [{ path: realpathSync(project), memory: 'content' }],
-        home: realpathSync(project),
-        paused_at: null,
-        created_at: '2026-01-01T00:00:00.000Z',
-        last_used_at: null,
-    }));
+    insertStoredProfile(join(home, '.crouter'), {
+        profileId,
+        manifest: {
+            schema_version: 1,
+            name: 'sync fixture',
+            projects: [{ path: realpathSync(project), memory: 'content' }],
+            home: realpathSync(project),
+            paused_at: null,
+            created_at: '2026-01-01T00:00:00.000Z',
+            last_used_at: null,
+        },
+    }, join(home, '.crouter', 'profiles', profileId));
+    resetScopeCache();
+}
+function lintFixtureStore(home, project) {
+    const previousHome = process.env['HOME'];
+    process.env['HOME'] = home;
+    resetScopeCache();
+    try {
+        return lintMemoryStore(openProjectMemoryStore(project));
+    }
+    finally {
+        closeScopedStores();
+        resetScopeCache();
+        if (previousHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = previousHome;
+    }
 }
 test('sync project-guidance --overwrite preserves an authored root and still imports rules', () => {
     const home = fixtureHome('crtr-sync-project-guidance-');
@@ -158,7 +184,7 @@ Nested operating guidance.
     assert.match(nestedIndex, /on: read/);
     assert.match(nestedIndex, /packages\/tool\/\*\*\/\*\.ts/);
     assert.match(nestedIndex, /Nested operating guidance\./);
-    const lint = lintMemoryStore(openProjectMemoryStore(nested));
+    const lint = lintFixtureStore(home, nested);
     assert.equal(lint.ok, true, JSON.stringify(lint.findings));
 });
 test('sync project-guidance imports nested rules as leaves without a synthetic nested index', () => {

package/dist/commands/sys/branch.d.ts

@@ -0,0 +1,2 @@
+import type { BranchDef, LeafDef } from '../../core/command.js';
+export declare function defineSysBranch(children: (LeafDef | BranchDef)[]): BranchDef;

package/dist/commands/sys/branch.js

@@ -0,0 +1,19 @@
+import { defineBranch } from '../../core/command.js';
+const SYS_ROOT_ENTRY = {
+    concept: 'crtr configuration, diagnostics, and self-management',
+    desc: 'settings, config, setup, doctor, context, sync, migrate, update, version, feedback, logs, support, daemon',
+    useWhen: 'managing the crtr installation, inspecting diagnostics, or operating the crtrd supervisor process',
+};
+const SYS_HELP = {
+    name: 'sys',
+    summary: 'crtr system configuration, settings, diagnostics, and self-management',
+    model: 'Configuration and settings own durable behavior; diagnostics and support observe it. Setup, migration, sync, and update change installed or generated state, while daemon control owns the supervisor lifecycle.',
+};
+export function defineSysBranch(children) {
+    return defineBranch({
+        name: 'sys',
+        rootEntry: SYS_ROOT_ENTRY,
+        help: { ...SYS_HELP },
+        children,
+    });
+}