@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/model-pin-durability.test.d.ts

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

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

@@ -1,195 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/model-pin-durability.test.ts
-//
-// `modelProviderPinned` is durable node state with ONE derivation rule: it is
-// decided exactly once, at an explicit user model change, from that change's
-// RAW pre-normalize token — a concrete `<provider>/<model-id>` token pins;
-// logical `<family>/<tier>` refs, bare tiers (`ultra`), and family aliases
-// (`opus`/`sonnet`/`haiku`) unpins. Every other rebuild or persist (a
-// polymorph/lifecycle change with no new `--model`, a dormant model write whose
-// spec happens to normalize to a concrete cell, cycle_model/cycle_ladder,
-// provider-fallback/not-found/cooling re-drives) carries the existing flag
-// through VERBATIM — never re-infers it from the current model token's shape.
-// These tests lock in that rule at both the `buildLaunchSpec` rebuild seam and
-// the `persistDormantModel` persist seam, plus the qualified-token predicate
-// itself.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildLaunchSpec, isProviderPinnedModelToken, normalizeModel } from '../runtime/launch.js';
-import { defaultModelLaddersConfig } from '../../types.js';
-import { persistDormantModel } from '../runtime/model-swap.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { promote, reshapeNode } from '../runtime/promote.js';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-const ladders = defaultModelLaddersConfig();
-// The concrete cell the `ultra` tier normalizes to — the byte-equal collision at
-// the heart of #328. A raw `ultra` token is UNpinned; this concrete cell is
-// pinned. Assert the fixture holds so the tests below stay meaningful if the
-// default ladder ever drifts.
-const ULTRA_CELL = normalizeModel('ultra', ladders);
-const priorHome = process.env['HOME'];
-const priorCrtrHome = process.env['CRTR_HOME'];
-let home = '';
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-model-pin-durability-'));
-    process.env['HOME'] = home; // buildLaunchSpec reads merged launch config here
-    process.env['CRTR_HOME'] = home; // the canvas db lives here
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-});
-beforeEach(() => {
-    closeDb();
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    if (priorHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorHome;
-    if (priorCrtrHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorCrtrHome;
-    rmSync(home, { recursive: true, force: true });
-});
-function buildSpec(over) {
-    return buildLaunchSpec('developer', 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-        cwd: home,
-        profileId: null,
-        ...over,
-    }).launch;
-}
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: home,
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-test('fixture: a bare tier is unpinned; its normalized concrete cell reads as pinned', () => {
-    assert.equal(isProviderPinnedModelToken('ultra'), false, 'a bare tier is unpinned');
-    assert.equal(isProviderPinnedModelToken(ULTRA_CELL), true, 'a qualified concrete cell reads as pinned');
-});
-test('only concrete provider/id tokens pin; logical family/tier refs remain preferences', () => {
-    assert.equal(isProviderPinnedModelToken('anthropic/claude-fable-5:high'), true, 'a concrete anthropic id pins');
-    assert.equal(isProviderPinnedModelToken('openai-codex/gpt-5.6-sol:max'), true, 'the real openai-codex registry namespace pins, not just the family alias `openai`');
-    assert.equal(isProviderPinnedModelToken('amazon-bedrock/some-model-id'), true, 'any qualified provider/id pins — no undocumented exception for a provider outside the three built-in families');
-    assert.equal(isProviderPinnedModelToken('openai/ultra'), false, 'a qualified family/tier ref is logical and unpinned');
-    assert.equal(isProviderPinnedModelToken('ultra'), false, 'a bare tier has no `/` and stays unpinned');
-    assert.equal(isProviderPinnedModelToken('opus'), false, 'a bare family alias has no `/` and stays unpinned');
-});
-test('a new --model override freezes a concrete pick', () => {
-    for (const requested of ['anthropic/claude-fable-5:high', 'openai-codex/gpt-5.6-sol:max']) {
-        const launch = buildSpec({ model: requested, modelOverride: true });
-        assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
-        assert.equal(launch.modelExact, true, `${requested} is exact after resolution`);
-        assert.equal(launch.modelIntent, undefined, `${requested} has no portable route intent`);
-        assert.equal(launch.env.CRTR_MODEL_INTENT, undefined, `${requested} cannot re-enable fallback on revive`);
-    }
-});
-// A strength word is a preference, not a model identity. Freezing it made every
-// `--model medium` child fail closed on a canvas whose only authenticated route
-// belonged to another provider, while a sibling that passed no --model routed
-// fine. Exactness now follows the raw token's shape, not the mere presence of
-// an override.
-test('a new --model override keeps a portable ladder token routable', () => {
-    for (const requested of ['medium', 'strong', 'anthropic/opus', 'opus']) {
-        const launch = buildSpec({ model: requested, modelOverride: true });
-        assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
-        assert.equal(launch.modelExact, undefined, `${requested} is a preference, so it must not fail closed`);
-        assert.notEqual(launch.modelIntent, undefined, `${requested} keeps its route intent`);
-        assert.equal(launch.env.CRTR_MODEL_INTENT, `${launch.modelIntent.family}/${launch.modelIntent.strength}`, `${requested} hands the broker the intent route fallback needs`);
-        assert.equal(launch.modelProviderPinned, false, `${requested} names no provider to pin to`);
-    }
-});
-// Direction 1: an EXPLICIT concrete pin must SURVIVE a config/lifecycle rebuild
-// even when the carried override has portablized back to a bare tier.
-test('an explicit concrete pin survives a config/lifecycle rebuild whose portablized override reads as a bare tier', () => {
-    // The user's explicit pick — a concrete provider/id — is derived as pinned at
-    // the moment of the pick (first-spawn / an explicit new --model).
-    assert.equal(buildSpec({ model: ULTRA_CELL }).modelProviderPinned, true, 'the raw concrete pick derives pinned');
-    // A polymorph/lifecycle rebuild with NO new --model: node.ts passes the stored
-    // pin verbatim AND the node's model_override, which may have portablized to the
-    // bare `ultra` tier. The carried flag must win over the tier's shape.
-    assert.equal(buildSpec({ model: 'ultra', modelProviderPinned: true }).modelProviderPinned, true, 'the rebuild carries the pin verbatim, ignoring the override shape');
-    // A bare tier shape ALONE derives unpinned — this is exactly why the rebuild
-    // above MUST carry the flag instead of re-deriving it.
-    assert.equal(buildSpec({ model: 'ultra' }).modelProviderPinned, false, 'a bare tier alone derives unpinned');
-});
-// Direction 2: a deliberately TIER-run (unpinned) node must NOT be wrongly
-// re-pinned when a subsequent rebuild/persist normalizes its override to the
-// concrete cell it happens to share bytes with.
-test('reshape resolves a new --model override and keeps a family alias routable', () => {
-    createNode(node('override-node', {
-        model_override: 'strong',
-        launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
-    }));
-    reshapeNode('override-node', { model: 'anthropic/opus' });
-    const after = getNode('override-node');
-    const expected = normalizeModel('anthropic/opus', ladders);
-    assert.equal(after?.model_override, expected, 'the raw alias never becomes the durable override');
-    assert.equal(after?.launch?.model, expected, 'revive replays the resolved provider/model');
-    assert.equal(after?.launch?.modelExact, undefined, 'a family alias is a preference, so revive may still route');
-    assert.deepEqual(after?.launch?.modelIntent, { family: 'anthropic', strength: 'strong' }, 'the route intent follows the new alias');
-    assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, 'anthropic/strong');
-});
-test('reshape freezes a new concrete --model override as the exact revive recipe', () => {
-    createNode(node('concrete-override-node', {
-        model_override: 'strong',
-        launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
-    }));
-    reshapeNode('concrete-override-node', { model: 'anthropic/claude-fable-5:high' });
-    const after = getNode('concrete-override-node');
-    assert.equal(after?.model_override, 'anthropic/claude-fable-5:high', 'the concrete pick is the durable override');
-    assert.equal(after?.launch?.model, 'anthropic/claude-fable-5:high', 'revive replays the exact spec');
-    assert.equal(after?.launch?.modelExact, true, 'retries and revives reject substitutes');
-    assert.equal(after?.launch?.modelIntent, undefined);
-    assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, undefined);
-});
-test('promotion preserves the exact-model contract required to revive a private human-work fork', () => {
-    const exactModel = 'openai-codex/gpt-5.6-sol:max';
-    createNode(node('exact-node', {
-        model_override: exactModel,
-        launch: { extensions: [], env: {}, model: exactModel, modelProviderPinned: true, modelExact: true },
-    }));
-    promote('exact-node');
-    const after = getNode('exact-node');
-    assert.equal(after?.mode, 'orchestrator');
-    assert.equal(after?.launch?.model, exactModel);
-    assert.equal(after?.launch?.modelProviderPinned, true);
-    assert.equal(after?.launch?.modelExact, true, 'promotion must not create a launch recipe that reviveNode rejects');
-});
-test('a deliberately tier-run node is not wrongly re-pinned when a rebuild or persist normalizes its override to the concrete cell', () => {
-    // The buildLaunchSpec seam: an explicit `false` carried through a rebuild wins
-    // over a concrete override that would otherwise read as pinned.
-    assert.equal(buildSpec({ model: ULTRA_CELL, modelProviderPinned: false }).modelProviderPinned, false, 'the rebuild carries the unpinned decision verbatim, ignoring the concrete override shape');
-    // The persistDormantModel seam: a dormant node that starts PINNED (proving the
-    // persist path actually CLEARS a real prior pin, not just a fixture that was
-    // already `false`) receives an explicit raw bare-tier decision (`pinned:
-    // false`, computed by the caller from the raw `ultra` token BEFORE
-    // normalization). Persist must store that decision, not re-derive `true` from
-    // the concrete spec ULTRA_CELL normalizes to.
-    createNode(node('tier-node', {
-        model_override: ULTRA_CELL,
-        launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'openai/ultra' }, model: ULTRA_CELL, modelIntent: { family: 'openai', strength: 'ultra' }, modelProviderPinned: true },
-    }));
-    persistDormantModel('tier-node', ULTRA_CELL, false);
-    const after = getNode('tier-node');
-    assert.equal(after?.launch?.model, ULTRA_CELL, 'the concrete spec is persisted as the launch model');
-    assert.equal(after?.model_override, ULTRA_CELL, 'the concrete spec is persisted as the override');
-    assert.equal(after?.launch?.modelExact, true, 'an explicit model change remains exact on revive');
-    assert.equal(after?.launch?.modelIntent, undefined, 'an explicit concrete choice clears the prior logical route intent');
-    assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, undefined, 'the revived broker does not inherit the prior logical route intent');
-    assert.equal(after?.launch?.modelProviderPinned, false, 'an explicit bare-tier decision clears a prior pin — the raw-token decision wins over the concrete spec shape');
-});

package/dist/core/__tests__/model-routes-config.test.d.ts

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

package/dist/core/__tests__/model-routes-config.test.js

@@ -1,150 +0,0 @@
-import { after, afterEach, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { persistModelRoute, readConfig, readMergedLaunchConfig, readRawConfigAtRoot, writeRawConfig } from '../config.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { expandModelCandidates } from '../model-routes.js';
-import { piAgentDir } from '../runtime/package-health.js';
-import { resetScopeCache } from '../scope.js';
-let home;
-let work;
-let previousHome;
-function route(providerId = 'provider-x', family = 'family-x', credentialSource = 'source-x') {
-    return {
-        family,
-        credentialSource,
-        providerId,
-        models: {
-            ultra: `${providerId}/ultra`,
-            strong: `${providerId}/strong`,
-            medium: `${providerId}/medium`,
-            light: `${providerId}/light`,
-        },
-    };
-}
-function writeConfig(root, config) {
-    if (root === join(home, '.crouter')) {
-        writeRawConfig('user', config);
-        return;
-    }
-    mkdirSync(root, { recursive: true });
-    writeFileSync(join(root, 'config.json'), JSON.stringify(config));
-}
-before(() => {
-    previousHome = process.env.HOME;
-});
-beforeEach(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-model-routes-home-'));
-    work = mkdtempSync(join(tmpdir(), 'crtr-model-routes-work-'));
-    process.env.HOME = home;
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    initializeFreshScopedStore({ kind: 'provider', root: piAgentDir() });
-});
-afterEach(() => {
-    resetScopeCache();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(work, { recursive: true, force: true });
-});
-after(() => {
-    if (previousHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = previousHome;
-    resetScopeCache();
-});
-test('complete routes preserve arbitrary names and credential-source ordering', () => {
-    writeConfig(join(home, '.crouter'), {
-        modelRoutes: {
-            personal: route('shared-provider', 'family/one', 'personal source'),
-            funded: route('shared-provider', 'family/one', 'funded source'),
-        },
-        modelRouting: {
-            credentialSourceOrder: ['funded source', 'personal source'],
-            familyOrder: ['family/one'],
-            strengthFallback: ['strong'],
-        },
-    });
-    const config = readMergedLaunchConfig(work, null);
-    assert.deepEqual(config.modelRoutes?.personal?.models, route('shared-provider', 'family/one', 'personal source').models);
-    assert.deepEqual(expandModelCandidates({ kind: 'logical', family: 'family/one', strength: 'strong', spec: 'family/one/strong' }, work, null).map((candidate) => candidate.routeId), ['funded', 'personal'], 'same provider/model refs remain distinct candidates when routes differ');
-});
-test('a sparse upper-scope route patch overlays a complete lower route', () => {
-    writeConfig(join(home, '.crouter'), { modelRoutes: { shared: route() } });
-    writeConfig(join(work, '.crouter'), { modelRoutes: { shared: { models: { medium: 'provider-x/project-medium' } } } });
-    const config = readMergedLaunchConfig(work, null);
-    assert.equal(config.modelRoutes?.shared?.models.medium, 'provider-x/project-medium');
-    assert.equal(config.modelRoutes?.shared?.models.ultra, 'provider-x/ultra');
-});
-test('legacy sparse routes remain readable with no invented cells', () => {
-    writeConfig(join(home, '.crouter'), {
-        modelRoutes: {
-            legacy: { family: 'legacy', credentialSource: 'old', providerId: 'legacy-provider', models: { medium: 'legacy-provider/medium' } },
-        },
-    });
-    const config = readMergedLaunchConfig(work, null);
-    assert.equal(config.modelRoutes, undefined);
-    assert.deepEqual(config.legacyModelRoutes?.legacy?.models, { medium: 'legacy-provider/medium' });
-    assert.deepEqual(readConfig('user').legacyModelRoutes?.legacy?.models, { medium: 'legacy-provider/medium' });
-    assert.deepEqual(expandModelCandidates({ kind: 'logical', family: 'legacy', strength: 'medium', spec: 'legacy/medium' }, work, null).map((candidate) => candidate.modelId), ['medium']);
-});
-test('route records retain __proto__ ids when read and persisted', () => {
-    const root = join(home, '.crouter');
-    writeConfig(root, JSON.parse(JSON.stringify({ modelRoutes: { ['__proto__']: route() } })));
-    assert.deepEqual(readMergedLaunchConfig(work, null).modelRoutes?.['__proto__'], route());
-    persistModelRoute(root, '__proto__', route('persisted-provider'));
-    const raw = readRawConfigAtRoot(root);
-    assert.deepEqual(raw.modelRoutes['__proto__'], route('persisted-provider'));
-});
-test('route candidate identity distinguishes delimiter-containing route and provider ids', () => {
-    writeConfig(join(home, '.crouter'), {
-        modelRoutes: {
-            a: route('b:c', 'family', 'first'),
-            'a:b': route('c', 'family', 'second'),
-        },
-        modelRouting: {
-            credentialSourceOrder: ['first', 'second'],
-            familyOrder: ['family'],
-            strengthFallback: ['strong'],
-        },
-    });
-    assert.deepEqual(expandModelCandidates({ kind: 'logical', family: 'family', strength: 'strong', spec: 'family/strong' }, work, null).map((candidate) => candidate.routeId), ['a', 'a:b']);
-});
-test('route writes reject missing cells and provider-prefix mismatches with actionable diagnostics', () => {
-    const root = join(home, '.crouter');
-    const incomplete = { ...route(), models: { strong: 'provider-x/strong' } };
-    assert.throws(() => persistModelRoute(root, 'needs-all-rungs', incomplete), /model route "needs-all-rungs" is incomplete; missing strengths: ultra, medium, light/);
-    assert.throws(() => persistModelRoute(root, 'wrong-provider', { ...route(), models: { ...route().models, light: 'other/light' } }), /model route "wrong-provider" models.light provider prefix must equal providerId/);
-});
-test('invalid route entries do not block valid routes, and no valid routes falls back to local ladders', () => {
-    writeConfig(join(home, '.crouter'), {
-        modelRoutes: {
-            valid: route('valid-provider', 'valid family', 'valid source'),
-            invalid: { family: 'bad', credentialSource: 'bad', providerId: 'one', models: { ultra: 'two/u', strong: 'two/s', medium: 'two/m', light: 'two/l' } },
-        },
-    });
-    assert.deepEqual(Object.keys(readMergedLaunchConfig(work, null).modelRoutes ?? {}), ['valid']);
-    writeConfig(join(home, '.crouter'), {
-        modelRoutes: {
-            invalid: { family: 'bad', credentialSource: 'bad', providerId: 'one', models: { ultra: 'two/u', strong: 'two/s', medium: 'two/m', light: 'two/l' } },
-        },
-    });
-    assert.equal(readMergedLaunchConfig(work, null).modelRoutes, undefined);
-    assert.equal(expandModelCandidates({ kind: 'logical', family: 'anthropic', strength: 'strong', spec: 'anthropic/strong' }, work, null)[0]?.routeId, 'anthropic');
-});
-test('persistModelRoute touches only its raw route and deletes by restoring inheritance', () => {
-    const root = join(home, '.crouter');
-    const other = route('other-provider');
-    writeConfig(root, { modelRoutes: { other }, max_panes_per_window: 7 });
-    persistModelRoute(root, 'edited', route('edited-provider'));
-    let raw = readRawConfigAtRoot(root);
-    assert.deepEqual(raw.modelRoutes.other, other);
-    assert.deepEqual(raw.modelRoutes.edited, route('edited-provider'));
-    assert.equal(raw.modelLadders, undefined);
-    assert.equal(raw.max_panes_per_window, 7);
-    persistModelRoute(root, 'edited', undefined);
-    raw = readRawConfigAtRoot(root);
-    assert.deepEqual(raw.modelRoutes, { other });
-});

package/dist/core/__tests__/nested-store-discovery.test.d.ts

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

package/dist/core/__tests__/nested-store-discovery.test.js

@@ -1,89 +0,0 @@
-// Bounded descendant-store discovery (nested-stores.ts) and its resolver
-// opt-in: git owners enumerate via ls-files (tracked + untracked, .gitignore
-// respected, the input root excluded), non-git owners walk with a depth cap,
-// and `resolveMemoryDocForTarget` sees a nested doc only when the caller opts
-// into descendants.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/nested-store-discovery.test.ts
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { CrtrError } from '../errors.js';
-import { realpathOrSelf } from '../fs-utils.js';
-import { gitSync } from '../git.js';
-import { closeDb } from '../canvas/db.js';
-import { resetScopeCache } from '../scope.js';
-import { descendantStoreRoots } from '../nested-stores.js';
-import { resolveMemoryDocForTarget } from '../memory-resolver.js';
-let fakeHome;
-let prevHomeEnv;
-const cleanups = [];
-before(() => {
-    prevHomeEnv = process.env['HOME'];
-});
-beforeEach(() => {
-    closeDb();
-    resetScopeCache();
-    fakeHome = mkdtempSync(join(tmpdir(), 'crtr-descend-home-'));
-    process.env['HOME'] = fakeHome;
-    cleanups.push(fakeHome);
-});
-after(() => {
-    closeDb();
-    resetScopeCache();
-    for (const dir of cleanups)
-        rmSync(dir, { recursive: true, force: true });
-    if (prevHomeEnv === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = prevHomeEnv;
-});
-function makeStore(dir) {
-    const memoryDir = join(dir, '.crouter', 'memory');
-    mkdirSync(memoryDir, { recursive: true });
-    writeFileSync(join(memoryDir, 'INDEX.md'), '# store\n');
-}
-test('git owner: tracked and untracked stores found, gitignored and input-root stores excluded', () => {
-    // Distinct tmp root per case: descendantStoreRoots caches by root list.
-    const owner = realpathOrSelf(mkdtempSync(join(tmpdir(), 'crtr-descend-git-')));
-    cleanups.push(owner);
-    assert.equal(gitSync(['-C', owner, 'init'], undefined).status, 0, 'git init succeeds');
-    makeStore(owner); // the input root itself — must be excluded
-    makeStore(join(owner, 'pkg-tracked'));
-    makeStore(join(owner, 'pkg-untracked'));
-    makeStore(join(owner, 'ignored'));
-    writeFileSync(join(owner, '.gitignore'), 'ignored/\n');
-    assert.equal(gitSync(['-C', owner, 'add', 'pkg-tracked'], undefined).status, 0, 'git add succeeds (ls-files needs no commit or identity)');
-    const found = descendantStoreRoots([join(owner, '.crouter')]).map(realpathOrSelf);
-    assert.deepEqual([...found].sort(), [join(owner, 'pkg-tracked', '.crouter'), join(owner, 'pkg-untracked', '.crouter')].sort(), 'tracked + untracked stores, nothing gitignored, never the input root');
-});
-test('non-git owner: the walk finds a store at the depth cap and stops below it', () => {
-    const owner = realpathOrSelf(mkdtempSync(join(tmpdir(), 'crtr-descend-walk-')));
-    cleanups.push(owner);
-    const atCap = join(owner, 'd1', 'd2', 'd3', 'd4', 'd5', 'd6'); // depth 6
-    makeStore(atCap);
-    const belowCap = join(atCap, 'd7'); // depth 7
-    makeStore(belowCap);
-    const found = descendantStoreRoots([join(owner, '.crouter')]).map(realpathOrSelf);
-    assert.deepEqual(found, [join(atCap, '.crouter')], 'depth 6 found; depth 7 is past the cap');
-});
-test('resolveMemoryDocForTarget resolves a nested doc only with includeDescendants', () => {
-    const proj = join(fakeHome, 'proj');
-    mkdirSync(join(proj, '.crouter', 'memory'), { recursive: true }); // project scope engages
-    writeFileSync(join(proj, '.crouter', 'memory', 'INDEX.md'), '---\nnamespace: proj\n---\nPROJ STORE\n');
-    const nestedMemory = join(proj, 'sub', '.crouter', 'memory');
-    mkdirSync(nestedMemory, { recursive: true });
-    writeFileSync(join(nestedMemory, 'INDEX.md'), '# nested store\n');
-    writeFileSync(join(nestedMemory, 'guide.md'), '---\nkind: knowledge\n' +
-        'name: nested-guide\n' +
-        'when-and-why-to-read: When working in sub, this knowledge should be read because it carries the subsystem constraints.\n---\n' +
-        'NESTED GUIDE BODY\n');
-    const target = { cwd: proj, profileId: null, nodeId: null };
-    assert.throws(() => resolveMemoryDocForTarget('proj/sub/nested-guide', target, {}), (e) => e instanceof CrtrError && e.code === 'not_found', 'without the opt-in the flat ancestor stack does not see the nested store');
-    const doc = resolveMemoryDocForTarget('proj/sub/nested-guide', target, { includeDescendants: true });
-    assert.equal(doc.name, 'proj/sub/nested-guide', 'the root namespace composes with the nested owner path and local name');
-    assert.equal(doc.scope, 'project');
-    assert.ok(doc.body.includes('NESTED GUIDE BODY'));
-});

package/dist/core/__tests__/node-outcome.test.d.ts

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